sso-parent/sso-server/src/main/java/com/uas/sso/controller/UserspaceManagerController.java

package com.uas.sso.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.uas.account.ResultWrap;
import com.uas.account.entity.AppCreateInfo;
import com.uas.account.entity.MasterInfo;
import com.uas.account.entity.UserSpace;
import com.uas.account.entity.UserSpaceDetail;
import com.uas.account.util.AccountUtils;
import com.uas.sso.common.util.HttpUtil;
import com.uas.sso.core.Const;
import com.uas.sso.core.Status;
import com.uas.sso.dao.UserspaceDao;
import com.uas.sso.entity.App;
import com.uas.sso.entity.User;
import com.uas.sso.entity.Userspace;
import com.uas.sso.service.AppService;
import com.uas.sso.service.ApplyUserSpaceService;
import com.uas.sso.service.UserService;
import com.uas.sso.service.UserspaceService;
import com.uas.sso.util.FastjsonUtils;
import com.uas.sso.util.FileUrl;
import com.uas.sso.util.HttpUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.ui.ModelMap;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.net.URLEncoder;
import java.sql.Timestamp;
import java.util.*;

import static com.alibaba.fastjson.JSON.parseObject;
import static com.uas.sso.service.impl.UserspaceServiceImpl.SPACE_INIT_UU;

/**
 * 企业信息管理controller
 *
 * @author wangmh
 * @date 2018/1/5
 */
@RestController
@RequestMapping("/api/userspace")
public class UserspaceManagerController extends BaseController {

    @Autowired
    private UserspaceService userspaceService;

    @Autowired
    private UserService userService;

    @Autowired
    private AppService appService;

    @Autowired
    private ApplyUserSpaceService applyUserSpaceService;

    @Autowired
    private UserspaceDao userspaceDao;

    /**
     * 校验企业名称
     *
     * @param spaceName 企业名称
     * @return
     */
    @RequestMapping(value = "/checkSpaceName", method = RequestMethod.GET)
    public ModelMap checkSpaceName(String spaceName) {
        userspaceService.checkSpaceName(spaceName);
        return success();
    }

    /**
     * 校验企业营业执照号
     *
     * @param businessCode 企业名称
     * @return
     */
    @RequestMapping("/checkBusinessCode")
    public ModelMap checkBusinessCode(String businessCode) {
        userspaceService.checkBusinessCode(businessCode);
        return success();
    }

    /**
     * 校验企业是否被认证
     *
     * @author wangmh
     * @date 2018/1/11 20:51
     * @param spaceName 企业名称
     * @return
     */
    @RequestMapping(value = "/name/valid", method = RequestMethod.GET)
    public ModelMap spaceNameIsValid(String spaceName) {
        return success(new ModelMap("isValid", userspaceService.spaceNameIsValid(spaceName)));
    }

    /**
     * 校验营业执照号是否被认证
     *
     * @author wangmh
     * @date 2018/1/11 10:35
     * @param businessCode 营业执照号
     * @return
     */
    @RequestMapping(value = "/businessCode/valid", method = RequestMethod.GET)
    public ModelMap businessCodeIsValid(String businessCode) {
        return success(new ModelMap("isValid", userspaceService.businessCodeIsValid(businessCode)));
    }

    /**
     * 上传营业执照号
     * @param image 营业执照号
     * @return 图片地址
     * @throws Exception
     */
    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    public ModelMap uploadImage(MultipartFile image) throws Exception {
        int IMAGE_MAX_SIZE = 5 * 1024 * 1024;
        if (!(image == null || image.isEmpty())) {
            if (image.getSize() > IMAGE_MAX_SIZE) {
                return error("营业执照附件大小不要超过5M");
            }
            HttpUtils.Response response = HttpUtils.upload(FileUrl.FILE_UPLOAD, image, null);
            JSONObject obj = FastjsonUtils.parseObject(response.getResponseText());
            String path = (String) obj.get("path");
            if (path != null) {
                return success(path);
            } else {
                return error("请检查您的营业执照附件");
            }
        }
        return error("上传失败");
    }

    /**
     * 模糊搜索企业名称
     * @param keyword 关键字
     * @param number 获取数量
     * @return page对象
     */
    @RequestMapping(value = "/search/name", method = RequestMethod.GET)
    public ModelMap searchName(String keyword, @RequestParam(defaultValue = "5") int number) {
        if (StringUtils.isEmpty(keyword)) {
            return success();
        }
        return success(userspaceService.searchName(keyword, number));
    }

    /**
     * 根据企业名称查询企业
     * @param name 企业名称
     * @return 企业信息
     */
    @RequestMapping(value = "/info/name", method = RequestMethod.GET)
    public ModelMap findByName(String name) {
        if (StringUtils.isEmpty(name)) {
            return success();
        }
        return success(userspaceService.findBySpaceName(name));
    }

    /**
     * 根据企业名称查询企业
     * @param businessCode 企业营业执照号
     * @return 企业信息
     */
    @RequestMapping(value = "/info/businessCode", method = RequestMethod.GET)
    public ModelMap findByBusinessCode(String businessCode) {
        if (StringUtils.isEmpty(businessCode)) {
            return success();
        }
        return success(userspaceService.findByBusinessCode(businessCode));
    }

    /**
     * 根据企业名称查询企业
     * @param spaceUU 企业营业执照号
     * @return 企业信息
     */
    @RequestMapping(value = "/info/spaceUU", method = RequestMethod.GET)
    public ModelMap findBySpaceUU(Long spaceUU) {
        if (StringUtils.isEmpty(spaceUU)) {
            return success();
        }
        return success(userspaceService.findOne(spaceUU));
    }

    /**
     * 查询所有企业列表
     */
    @RequestMapping(params = "_operate=getUserSpaces")
    public Page<Userspace> getUserSpaces(String keyword, @RequestParam(defaultValue = "1") int pageNumber, @RequestParam(defaultValue = "20") int pageSize) {
        return userspaceService.findByKeyword(keyword, pageNumber, pageSize);
    }

    /**
     * 统计申请已审批和未审批数量
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(value = "/apply/count", method = RequestMethod.GET)
    public ModelMap applyCount(Long spaceUU) {
        return success(applyUserSpaceService.applyCount(spaceUU));
    }

    /**
     * 企业解除绑定应用
     * @param spaceUU 企业uu号
     * @param appId 应用id
     * @return
     */
    @RequestMapping(params = "_operate=unbind", method = RequestMethod.POST)
    public ModelMap unbindApp(Long spaceUU, String appId) {
        if (StringUtils.isEmpty(spaceUU) || StringUtils.isEmpty(appId)) {
            return error("参数错误");
        }

        userspaceService.unbindApp(spaceUU, appId);
        return success();
    }

    /**
     * 企业开通应用
     * @param spaceUU 企业uu号
     * @param appId 应用id
     * @return
     */
    @RequestMapping(params = "_operate=bind", method = RequestMethod.POST)
    public ModelMap bindApp(Long spaceUU, String appId) {
        if (StringUtils.isEmpty(spaceUU) || StringUtils.isEmpty(appId)) {
            return error("参数错误");
        }

        userspaceService.bindApp(spaceUU, appId);
        return success();
    }


    /**
     * 校验企业营业执照
     *
     * @param businessCode 营业执照号
     * @return
     * @throws UnsupportedEncodingException
     */
    @RequestMapping(params = "_operate=validBusinessCode", method = RequestMethod.GET)
    public AppCreateInfo validBusinessCode(String businessCode) throws UnsupportedEncodingException {
        // 去掉可能存在的空格再进行检验
        businessCode = StringUtils.trimAllWhitespace(businessCode);
        AppCreateInfo info = new AppCreateInfo();
        info.setHasCreate(false);
        info.setInCloud(false);
        if (!StringUtils.isEmpty(businessCode)) {
            Userspace userspace = userspaceService.findByBusinessCode(businessCode);
            if (null != userspace && userspace.getApps() != null) {
                for (App app : userspace.getApps()) {
                    // 是否注册过saas
                    if (app.getUid().equals("saas")) {
                        info.setHasCreate(true);
                        continue;
                    }
                    // 是否注册过uas
                    if (app.getUid().equals("uas")) {
                        info.setHasCreate(true);
                        continue;
                    }
                    // 是否注册过平台
                    if (app.getUid().equals("b2b")) {
                        info.setInCloud(true);
                        info.setName(userspace.getSpaceName());
                        continue;
                    }
                }
            }
        }
        return info;
    }

    /**
     * 校验企业名称
     *
     * @param name
     * @return
     */
    @RequestMapping(params = "_operate=validName", method = RequestMethod.GET)
    public AppCreateInfo validName(String name) {
        // 去掉可能存在的空格再进行检验
        name = StringUtils.trimAllWhitespace(name);
        AppCreateInfo info = new AppCreateInfo();
        info.setHasCreate(false);
        info.setInCloud(false);
        if (!StringUtils.isEmpty(name)) {
            Userspace userspace = userspaceService.findBySpaceName(name);
            if (null != userspace && userspace.getApps() != null) {
                for (App app : userspace.getApps()) {
                    // 是否注册过saas
                    if (app.getUid().equals("saas")) {
                        info.setHasCreate(true);
                        continue;
                    }
                    // 是否注册过uas
                    if (app.getUid().equals("uas")) {
                        info.setHasCreate(true);
                        continue;
                    }
                    // 是否注册过平台
                    if (app.getUid().equals("b2b")) {
                        info.setInCloud(true);
                        info.setBusinessCode(userspace.getBusinessCode());
                        continue;
                    }
                }
            }
        }
        return info;
    }

    /**
     * ERP、SAAS新开账套注册平台
     *
     * @param detail
     * @param userInfos
     */
    @RequestMapping(params = "_operate=registerBranchAccount", method = RequestMethod.POST)
    public AppCreateInfo applyApp(String detail, String userInfos) {
        AppCreateInfo info = new AppCreateInfo();

        // 获取接收到的信息
        List<User> users = JSON.parseArray(userInfos, User.class);
        Userspace userspace = parseObject(detail, Userspace.class);

        // 企业注册
        userspace = userspaceService.register(userspace, "uas");

        // 将用户绑定绑定到注册企业
        userspaceService.addUser(userspace, users);

        // 注册完后查询uu号等信息
        info.setInCloud(true);
        info.setEnuu(userspace.getSpaceUU() + "");
        return info;
    }

    /**
     * 同步旧企业数据到账户中心
     * @param spaceUU 企业uu号，为空则同步所有
     * @return
     */
    @RequestMapping("/saveOldUserSpaces/{spaceUU}")
    public ModelMap syncOldUserSpaces(@PathVariable Long spaceUU, @RequestParam(defaultValue = "1") int pageNumber,
                                      @RequestParam(defaultValue = "20")int pageSize, @RequestParam(defaultValue = "false") boolean isAll) {
        // 由于旧数据问题，记录重复的企业名称和营业执照号
        Map<String, Integer> repeatSpaceName = new HashMap<>();
        Map<String, Integer> repeatBusinessCode = new HashMap<>();

        Userspace userspace;
        com.uas.sso.support.Page<UserSpaceDetail> page = null;
        // 循环分页请求，如果是最后一页则退出循环
        while (page == null || !page.isLast()) {
            // 获取分页信息
            page = getUserSpace(pageNumber++, pageSize);

            // 循环遍历企业信息并保存
            int i = 1;
            for (UserSpaceDetail detail : page.getContent()) {
                try {
                    userspace = userspaceService.findByBusinessCode(detail.getBusinessCode());
                    if (userspace != null) {
                        continue;
                    }
                    userspace = saveUserspace(detail);
                    System.out.println(page.getNumber() + "\t" + page.getSize() + "\t" + i++ + "\t" + userspace.getSpaceName() + "\t" + userspace.getBusinessCode());
                } catch (Exception e) {
                    writerToFile(page.getNumber() + "\t" + page.getSize() + "\t" + i++ + "\t" + detail.getName() + "\t" + detail.getBusinessCode(), e.getMessage());
                }
            }
            spaceNameUnique();
            if (!isAll) {
                break;
            }
        }
        return success();
    }

    private Userspace saveUserspace(UserSpaceDetail detail) throws Exception {
        Userspace userspace;
        userspace = new Userspace();
        // 设置企业秘钥
        userspace.setAccessSecret(getAccessSecret(detail.getBusinessCode()));
        // 设置管理员uu号
        User user = userService.findByMobile(detail.getAdminTel());
        userspace.setAdminUU(user == null ? null : user.getUserUU());
        userspace.setBusinessCode(detail.getBusinessCode());
        userspace.setBusinessCodeImage(detail.getBusinessCodeImage());
        userspace.setCorporation(detail.getCorporation());
        userspace.setDomain(detail.getDomain());
        userspace.setLogoImage(detail.getLogoImage());
        userspace.setProfession(detail.getProfession());
        userspace.setRegAddress(detail.getAddress());
        userspace.setRegCity(detail.getCity());
        userspace.setRegDistrict(detail.getDistrict());
        userspace.setRegProvince(detail.getProvince());
        userspace.setRegStreet(detail.getStreet());
        userspace.setRegisterDate(detail.getRegisterDate() == null ? null : new Timestamp(detail.getRegisterDate()));
        userspace.setSpaceName(detail.getName());
        // 设置企业uu号
        userspace.setSpaceUU(getSpaceUU(detail.getBusinessCode(), detail.getName()));
        userspace.setTags(detail.getTags());
        userspace.setTelephone(detail.getTel());
        userspace.setValidCode((short) Status.AUTHENTICATED.getCode());
        if (userspace.getSpaceUU() == null) {
            throw new Exception("无uu号");
        }
//        userspace.setWebsite(getWebsite());

        // 设置企业用户
        addUsersByBusinessCode(userspace);

        // 设置默认应用
        addDefaultApp(userspace);
        userspaceService.save(userspace);
        return userspace;
    }

    private void addDefaultApp(Userspace userspace) throws Exception {
        if (userspace.getApps() == null) {
            userspace.setApps(new ArrayList<App>());
        }
        String url = "http://10.1.51.50:8080/api/userspace";
        ModelMap data = new ModelMap();
        data.put("businessCode", userspace.getBusinessCode());
        data.put("_operate", "getapp");
        HttpUtil.ResponseWrap res = HttpUtil.doGet(url, data);
        if (!res.isSuccess()) {
            throw new Exception(res.getContent());
        } else {
            ResultWrap result = JSON.parseObject(res.getContent(), ResultWrap.class);
            if (!result.isSuccess()) {
                throw new Exception(result.getErrMsg());
            } else if (result.getContent() != null){
                List<UserSpace> userSpaceList = JSON.parseArray(result.getContent().toString(), UserSpace.class);
                for (int i=0; i<userSpaceList.size(); i++) {
                    App app = appService.findOne(userSpaceList.get(i).getAppId());
                    if (app != null && !userspace.getApps().contains(app)) {
                        userspace.getApps().add(app);
                    }
                }
                App app = appService.findOne("sso");
                if (!userspace.getApps().contains(app)) {
                    userspace.getApps().add(app);
                }
                app = appService.findOne("mall");
                if (!userspace.getApps().contains(app)) {
                    userspace.getApps().add(app);
                }
            }
        }
    }

    private void addUsersByBusinessCode(Userspace userspace) throws Exception {
        if (userspace.getUsers() == null) {
            userspace.setUsers(new ArrayList<User>());
        }
        int pageNumber = 1;
        int pageSize = 20;
        com.uas.sso.support.Page<com.uas.account.entity.User> page;
        String url = "http://10.1.51.50:8080/api/user";
        url = url + "/findByBusinessCode";
        do {
            ModelMap data = new ModelMap();
            data.put("businessCode", userspace.getBusinessCode());
            data.put("appId", "b2b");
            data.put("pageNumber", pageNumber++);
            data.put("pageSize", pageSize);
            HttpUtil.ResponseWrap res = HttpUtil.doGet(url, data);
            if (!res.isSuccess()) {
                throw new Exception(res.getContent());
            } else {
                page = JSON.parseObject(res.getContent(), new TypeReference<com.uas.sso.support.Page<com.uas.account.entity.User>>() {});
                List<com.uas.account.entity.User> users = page.getContent();
                for (int i = 0; i < users.size(); i++) {
                    User user = users.get(i).getDialectUID() == null ? userService.findByMobile(users.get(i).getUid()) : userService.findOne(Long.valueOf(users.get(i).getDialectUID()));
                    if (user != null && !userspace.getUsers().contains(user)) {
                        userspace.getUsers().add(user);
                    }
                }
            }
        } while (page == null || !page.isLast());
    }

    private Long getSpaceUU(String businessCode, String name) throws Exception {
        if (StringUtils.isEmpty(businessCode)) {
            return null;
        }

        String url = "http://10.1.51.50:8080/api/userspace/info";
        if (!StringUtils.isEmpty(businessCode)) {
            businessCode = businessCode.trim();
        }
        if (!StringUtils.isEmpty(name)) {
            name = name.trim();
        }
//        url = url + "/" + URLEncoder.encode(businessCode, "UTF-8") + "/" + URLEncoder.encode(name, "UTF-8");
        HttpUtil.ResponseWrap res = null;
        ModelMap data = new ModelMap();
        data.put("businessCode", businessCode);
        data.put("name", name);
        res = HttpUtil.doGet(url, data);
        if(res.isSuccess() && !StringUtils.isEmpty(res.getContent())) {
            JSONObject jsonObject = JSON.parseObject(res.getContent());
            if (jsonObject.containsKey("dialectUID")) {
                return Long.valueOf(jsonObject.get("dialectUID").toString());
            }
        }
        return null;
    }

    public com.uas.sso.support.Page<UserSpaceDetail> getUserSpace(@RequestParam(defaultValue = "1") int pageNumber, @RequestParam(defaultValue = "20") int pageSize) {
        com.uas.sso.support.Page<UserSpaceDetail> page = null;
        String url = "http://10.1.51.50:8080/api/partners";
        if(!StringUtils.isEmpty(url)) {
            HttpUtil.ResponseWrap res = null;
            try {
                ModelMap data = new ModelMap("_operate", "getUserSpaces");
                data.put("pageNumber", Integer.valueOf(pageNumber));
                data.put("pageSize", Integer.valueOf(pageSize));
                res = HttpUtil.doGet(url, data);
                if(res.isSuccess()) {
                    return JSON.parseObject(res.getContent(), new TypeReference<com.uas.sso.support.Page<UserSpaceDetail>>() {});
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return page;
    }

    /**
     * 从b2b获取erp企业秘钥
     * @return
     */
    @RequestMapping(value = "/saveAccessSecret/{businessCode}")
    public ModelMap saveAccessSecret(@PathVariable String businessCode) throws UnsupportedEncodingException {
        if (!StringUtils.isEmpty(businessCode)) {
            getAccessSecret(businessCode);
        }
        return success();
    }

    /**
     * 从b2b获取密钥
     * @param businessCode 营业执照号
     * @return
     */
    public String getAccessSecret(String businessCode) throws UnsupportedEncodingException {
        String url = "http://10.1.51.50:8090/platform-b2b";
        url = url + "/account/enterprise/info/" + URLEncoder.encode(businessCode, "UTF-8");
        String accessSecret = null;
        try {
            HttpUtil.ResponseWrap responseWrap = HttpUtil.doGet(url);
            if (responseWrap.isSuccess()) {
                JSONObject enterprise = parseObject(responseWrap.getContent());
                accessSecret = (String) enterprise.get("accessSecret");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return accessSecret;
    }

    /**
     * 写入日志
     * @param businessCode 营业执照号
     * @param accessSecret 密钥
     */
    private void writerToFile(String businessCode, String accessSecret) {
        FileWriter fw = null;
        try {
            //如果文件存在，则追加内容；如果文件不存在，则创建文件
            File f=new File("logs/userspace.log");
            fw = new FileWriter(f, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        PrintWriter pw = new PrintWriter(fw);
        pw.println(businessCode + "\t" + accessSecret);
        pw.flush();
        try {
            fw.flush();
            pw.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @RequestMapping("/spaceName/unique")
    public ModelMap spaceNameUnique() {
        List<String> repeatName = userspaceService.findRepeatName();
        for (String name : repeatName) {
            List<Userspace> userspaces = userspaceService.findAllBySpaceName(name);
            for (int i=0; i<userspaces.size(); i++) {
                Userspace userspace = userspaces.get(i);
                userspace.setSpaceName(userspace.getSpaceName() + Const.REPEAT_SEPARATOR + (i + 1));
                userspaceService.save(userspace);
            }
        }
        return success();
    }

    /**
     * 从其他应用注册企业信息
     * @param userspace 企业信息
     */
    @RequestMapping(value = "/register/other", method = RequestMethod.POST)
    public ModelMap registerFromOther(Userspace userspace, User admin, String appId) {
        if (userspace == null || admin == null) {
            return error("参数错误");
        }
        userspace.setAdmin(admin);
        return success(userspaceService.register(userspace, appId));
    }

    /**
     * 通过id查询企业信息（方便平台搜索调用）
     *
     * @param ids
     * @return
     */
    @RequestMapping(params = "_operate=findAll")
    @ResponseBody
    public List<Userspace> findAll(String ids) {
        return userspaceService.findAll(ids);
    }

    @RequestMapping("/getWebsite")
    public String getWebsite() {
        String url = "http://10.1.51.50:8080/api/userspace/getWebsite";
        int pageNumber = 3;
        int pageSize = 20;
        com.uas.account.support.Page<MasterInfo> page = null;
        do {
            try {
                ModelMap data = new ModelMap();
                data.put("pageNumber", pageNumber++);
                data.put("pageSize", pageSize);
                HttpUtil.ResponseWrap responseWrap = HttpUtil.doGet(url, data);
                if (responseWrap.isSuccess()) {
                    try {
                        page = JSON.parseObject(responseWrap.getContent(), new TypeReference<com.uas.account.support.Page<MasterInfo>>() {
                        });
                        for (MasterInfo masterInfo : page.getContent()) {
                            try {
                                Userspace userspace = userspaceService.findByBusinessCode(masterInfo.getBusinessCode());
                                if (userspace == null) {
                                    userspace = userspaceService.findBySpaceName(masterInfo.getName());
                                }
                                if (userspace == null && !StringUtils.isEmpty(masterInfo.getUu())) {
                                    userspace = userspaceService.findOne(Long.valueOf(masterInfo.getUu()));
                                }
                                if (userspace != null && masterInfo.getWebsite() != null) {
                                    userspace.setWebsite(masterInfo.getWebsite());
                                    userspaceService.save(userspace);
                                }

                                if (userspace == null && !StringUtils.isEmpty(masterInfo.getPlatform())) {
                                    userspace = new Userspace();
                                    userspace.setSpaceName(masterInfo.getName());
                                    userspace.setBusinessCode(masterInfo.getBusinessCode());
                                    userspace.setValidCode((short) Status.NOT_APPLYING.getCode());
                                    userspace.setWebsite(masterInfo.getWebsite());
                                    // 设置uu号
                                    Long maxUU = userspaceDao.findMaxUU();
                                    userspace.setSpaceUU(maxUU < 10050000L ? 10050000L : (maxUU + 1));
                                    userspace.setApps(new ArrayList<App>());
                                    userspace.getApps().add(appService.findOne(masterInfo.getPlatform()));
                                    userspace = userspaceService.save(userspace);
                                    System.out.println(String.format("%s\t%s\t%s", userspace.getSpaceName(), userspace.getBusinessCode(), userspace.getSpaceUU()));
                                }
                                if (CollectionUtils.isEmpty(userspace.getUsers())) {
                                    userspace.setUsers(new ArrayList<User>());
                                }
                                if (!StringUtils.isEmpty(masterInfo.getUu())) {
                                    continue;
                                }
                                com.uas.account.support.Page<com.uas.account.entity.User> userInfos = null;
                                int pageNumber2 = 1;
                                int pageSize2 = 20;
                                do {
                                    userInfos = AccountUtils.findUsersByBusinessCode(userspace.getBusinessCode(), pageNumber2++, pageSize2);
                                    for (com.uas.account.entity.User userInfo : userInfos.getContent()) {
                                        try {
                                            User user = userService.findByMobile(userInfo.getUid());
                                            if (!userInfo.getAppId().equals("b2b") && !userspace.getUsers().contains(user)) {
                                                userspace.getUsers().add(user);
                                            }
                                        } catch (Exception e) {
                                            System.out.println(userInfo.getName() + "\t" + userInfo.getUid() + "\t" + e.getMessage());
                                        }
                                    }
                                } while (userInfos == null || !userInfos.isLast());
                                userspace = userspaceService.save(userspace);
                            } catch (Exception e) {
                                System.out.println((pageNumber-1) + "\t" + masterInfo.getName() + "\t" +e.getMessage());
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } while (page == null || !page.isLast());
        return null;
    }

    @RequestMapping("/delete")
    public ModelMap delete() {
        List<Userspace> userspaces = userspaceDao.findtest();
        userspaceDao.delete(userspaces);
        return success();
    }

    @RequestMapping("/update")
    public ModelMap update () {
        Userspace userspace = userspaceDao.findOne(20000012L);
        userspace.setSpaceUU(10050072L);
        userspaceDao.save(userspace);

        userspace = userspaceDao.findOne(20000013L);
        userspace.setSpaceUU(10050073L);
        userspaceDao.save(userspace);
        return success();
    }
}