mobile.service.GroupService.java Source code

Java tutorial

Introduction

Here is the source code for mobile.service.GroupService.java

Source

/*
 * Copyright (c) 2013, Helome and/or its affiliates. All rights reserved.
 * Helome PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 * Created on 201488
 */
package mobile.service;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import controllers.base.ObjectNodeResult;
import controllers.user.UserGroupsApp;
import exception.AvatarException;
import ext.msg.model.Message;
import ext.msg.model.Message.MsgType;
import ext.msg.model.service.MessageService;
import ext.usercenter.UCClient;
import mobile.service.result.ServiceResult;
import mobile.service.result.ServiceVOResult;
import mobile.vo.group.GroupDetailVO;
import mobile.vo.group.GroupMember;
import mobile.vo.group.GroupVO;
import mobile.vo.result.CommonVO;
import mobile.vo.result.MobilePage;
import models.Group;
import models.Group.GroupPriv;
import models.Group.Type;
import models.SkillTag;
import models.User;
import models.service.ChatService;
import models.service.ChatService.CreateTranslateGroupResult;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.springframework.util.CollectionUtils;
import play.Logger;
import play.Logger.ALogger;
import play.db.jpa.JPA;
import play.libs.Json;
import play.mvc.Http.Context;
import play.mvc.Http.Session;
import utils.Assets;
import vo.GroupMemberVO;
import vo.page.Page;

import java.io.File;
import java.io.IOException;
import java.util.*;

/**
 * @author ShenTeng
 * @ClassName: GroupService
 * @Description: ?
 * @date 201488 ?2:39:53
 */
public class GroupService {

    private static final ALogger LOGGER = Logger.of(GroupService.class);

    /**
     * 
     *
     * @param userId       ?Id
     * @param translatorId Id
     * @return
     */
    public static ServiceVOResult<CommonVO> createTranslateGroup(Long userId, Long translatorId) {
        Session session = Context.current().session();
        User me = User.getFromSession(session);
        User you = User.findById(userId);
        User translator = User.findById(translatorId);
        if (you == null) { // ?
            you = UCClient.queryUserById(userId);
        }
        if (translator == null) { // ?
            translator = UCClient.queryUserById(translatorId);
        }

        if (you == null || translator == null) {
            return ServiceVOResult.error("100005", "?");
        }
        if (you.getId() - translator.getId() == 0) {
            return ServiceVOResult.error("100005", "???");
        }
        if (me.getId().equals(userId) || me.getId().equals(translatorId)) {
            return ServiceVOResult.error("100005", "????");
        }

        CreateTranslateGroupResult result;
        try {
            result = models.service.ChatService.createTranslateGroup(me, you, translator);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        if (!result.isExist()) {
            CommonVO vo = CommonVO.create();
            vo.set("groupId", result.getGroup().getId());
            vo.set("groupName", result.getGroup().getGroupName());

            ServiceVOResult<CommonVO> serviceVOResult = ServiceVOResult.success();
            serviceVOResult.setVo(vo);
            return serviceVOResult;
        } else {
            return ServiceVOResult.error("285001", "??????");
        }
    }

    /**
     * 
     *
     * @param userIdList Id
     * @return
     */
    public static ServiceVOResult<CommonVO> createMultiCommunicate(List<Long> userIdList) {
        User me = User.getFromSession(Context.current().session());

        if (userIdList.contains(me.getId())) {
            return ServiceVOResult.error("100005", "??");
        }

        ObjectNodeResult objectNodeResult = null;
        try {
            objectNodeResult = ChatService.createMultiCommunicateGroup(me, userIdList);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        if (!objectNodeResult.isSuccess()) {
            Logger.error(objectNodeResult.getObjectNode().toString());
            return ServiceVOResult.error("100001", "");
        }

        CommonVO vo = CommonVO.create();
        vo.set("groupId", objectNodeResult.getObjectNode().path("groupId").asLong());
        vo.set("groupName", objectNodeResult.getObjectNode().path("groupName").asText());

        return ServiceVOResult.success(vo);
    }

    /**
     * ??
     *
     * @param pageIndex 1
     * @param pageSize  ??
     * @param groupId   Id
     * @return
     */
    public static MobilePage<GroupMember> getGroupMemberList(int pageIndex, int pageSize, Long groupId) {
        Page<GroupMemberVO> page = models.service.ChatService.queryGroupMemberByPage(pageIndex, pageSize, groupId,
                null);

        MobilePage<GroupMember> mobilePage = new MobilePage<GroupMember>(page.getTotalRowCount(),
                GroupMember.createList(page.getList()));

        return mobilePage;
    }

    /**
     * 
     *
     * @param pageIndex  1
     * @param pageSize   ??
     * @param industryId Id?
     * @param privacy    ???
     * @param skillTag   ?
     * @return Page
     */
    public static MobilePage<GroupVO> getGroupPage(int pageIndex, int pageSize, Long industryId, String privacy,
            String skillTag) {
        GroupPriv groupPriv = GroupPriv.getByName(privacy);
        Page<vo.GroupVO> groupPage = ChatService.queryGroupByPage(true, pageIndex, pageSize, industryId, groupPriv,
                skillTag, null, null);

        List<GroupVO> list = new ArrayList<GroupVO>(groupPage.getList().size());
        for (vo.GroupVO source : groupPage.getList()) {
            list.add(GroupVO.create(source));
        }

        MobilePage<GroupVO> page = new MobilePage<GroupVO>(groupPage.getTotalRowCount(), list);
        return page;
    }

    /**
     * ?
     *
     * @param groupId Id
     * @return
     */
    public static ServiceVOResult<GroupDetailVO> getGroupDetail(Long groupId) {
        Group group = Group.queryGroupById(groupId);
        if (null == group) {
            return ServiceVOResult.error("2001", "?");
        }

        vo.GroupVO webVo = new vo.GroupVO();
        webVo.convert(group);

        GroupDetailVO groupDetailVO = GroupDetailVO.create(webVo);

        return ServiceVOResult.success(groupDetailVO);
    }

    /**
     * ?
     *
     * @param pageIndex   1
     * @param pageSize    ??
     * @param typeStrList ? NORMAL - TRANSLATE - MULTICOMMUNICATE - ?
     * @param isOwner     ??
     * @return
     */
    public static MobilePage<GroupVO> getMyGroupPage(int pageIndex, int pageSize, List<String> typeStrList,
            Boolean isOwner, String groupName) {
        User me = User.getFromSession(Context.current().session());

        List<Type> typeList = new ArrayList<Group.Type>();
        for (String typeStr : typeStrList) {
            Type type = Type.getByName(typeStr);
            if (null != type) {
                typeList.add(type);
            }
        }

        Page<Group> poPage = Group.queryByPage(pageIndex, pageSize, null, null, null, groupName, typeList,
                me.getId(), isOwner, "id", true);

        List<GroupVO> list = new ArrayList<GroupVO>();
        for (Group po : poPage.getList()) {
            vo.GroupVO webVO = new vo.GroupVO();
            webVO.convert(po);
            GroupVO vo = GroupVO.create(webVO);
            vo.setIsJoin(true);
            list.add(vo);
        }

        MobilePage<GroupVO> page = new MobilePage<GroupVO>(poPage.getTotalRowCount(), list);
        return page;
    }

    /**
     * 
     *
     * @param groupName  ??
     * @param industryId Id
     * @param groupInfo  ?
     * @param groupPriv  ??
     * @param skillsTags 
     * @return
     */
    public static ServiceVOResult<CommonVO> createGroup(String groupName, Long industryId, String groupInfo,
            String groupPriv, List<String> skillsTags) {
        GroupPriv priv = GroupPriv.getByName(groupPriv);
        if (null == priv) {
            return ServiceVOResult.error("100005", "??" + groupPriv);
        }
        if (StringUtils.isBlank(groupName)) {
            return ServiceVOResult.error("100005", "???");
        }
        SkillTag tag = SkillTag.getTagById(industryId);
        if (null == tag || tag.getTagType() != SkillTag.TagType.CATEGORY) {
            return ServiceVOResult.error("100005", "Id" + industryId);
        }

        ObjectNode data = Json.newObject();
        data.put("groupName", groupName);
        data.put("industry", industryId);
        data.put("groupPriv", priv.ordinal());
        data.put("groupInfo", groupInfo);
        data.set("tags", Json.toJson(skillsTags));

        User me = User.getFromSession(Context.current().session());

        ObjectNodeResult objectNodeResult = Group.saveGroupByJson(me, data);

        if (!objectNodeResult.isSuccess()) {
            if ("900003".equals(objectNodeResult.getErrorCode())) {
                return ServiceVOResult.error("294001", objectNodeResult.getError());
            }
            Logger.error(objectNodeResult.getObjectNode().toString());
            return ServiceVOResult.error("100001", "");
        }

        CommonVO vo = CommonVO.create();
        vo.set("groupId", objectNodeResult.getObjectNode().path("groupId").asLong(-1));

        return ServiceVOResult.success(vo);
    }

    /**
     * 
     *
     * @param groupId    Id
     * @param groupName  ???
     * @param industryId Id?
     * @param groupInfo  ?
     * @param groupPriv  ???
     * @param skillsTags ?
     * @return
     */
    public static ServiceResult updateGroup(Long groupId, String groupName, Long industryId, String groupInfo,
            String groupPriv, List<String> skillsTags) {
        ObjectNode data = Json.newObject();
        User me = User.getFromSession(Context.current().session());

        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.NORMAL) {
            return ServiceResult.error("100005", "??");
        }
        if (null == group) {
            return ServiceResult.error("2001", "?");
        } else if (!Objects.equals(group.getOwner().getUserId(), me.getId())) {
            return ServiceResult.error("2002", "??");
        }
        data.put("id", groupId);

        if (null != groupName) {
            if (StringUtils.isBlank(groupName)) {
                return ServiceResult.error("100005", "???");
            }
            data.put("groupName", groupName);
        }

        if (null != industryId) {
            SkillTag tag = SkillTag.getTagById(industryId);
            if (null == tag || tag.getTagType() != SkillTag.TagType.CATEGORY) {
                return ServiceResult.error("100005", "Id" + industryId);
            }
            data.put("industry", industryId);
        }

        if (null != groupPriv) {
            GroupPriv priv = GroupPriv.getByName(groupPriv);
            if (null == priv) {
                return ServiceResult.error("100005", "??" + groupPriv);
            }

            data.put("groupPriv", priv.ordinal());
        }

        if (null != skillsTags) {
            data.set("tags", Json.toJson(skillsTags));
        }

        if (null != groupInfo) {
            data.put("groupInfo", groupInfo);
        }

        ObjectNodeResult objectNodeResult = Group.saveGroupByJson(me, data);

        if (!objectNodeResult.isSuccess()) {
            if ("900003".equals(objectNodeResult.getErrorCode())) {
                return ServiceResult.error("295001", objectNodeResult.getError());
            }
            Logger.error(objectNodeResult.getObjectNode().toString());
            return ServiceResult.error("100001", "");
        }

        return ServiceResult.success();
    }

    /**
     * ?
     *
     * @param groupId    Id
     * @param avatarFile ?length>0
     * @return
     */
    public static ServiceVOResult<CommonVO> updateGroupAvatar(Long groupId, File avatarFile) {
        if (null == groupId || null == avatarFile || avatarFile.length() <= 0) {
            throw new IllegalArgumentException(
                    "groupId?avatarFile is null or avatarFile.length() <= 0. groupId = " + groupId
                            + ", avatarFile = " + avatarFile);
        }

        User me = User.getFromSession(Context.current().session());
        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.NORMAL) {
            return ServiceVOResult.error("100005", "??");
        }
        if (null == group) {
            return ServiceVOResult.error("2001", "?");
        } else if (!Objects.equals(group.getOwner().getUserId(), me.getId())) {
            return ServiceVOResult.error("2002", "??");
        }

        ObjectNodeResult nodeResult = new ObjectNodeResult();
        try {
            UserGroupsApp.save(avatarFile, nodeResult, me);
        } catch (AvatarException e) {
            LOGGER.error("?", e);
            return ServiceVOResult.error("100001", "?");
        }

        String headUrl = nodeResult.getObjectNode().path("avatar_190_source").asText();
        ObjectNode data = Json.newObject();
        data.put("headUrl", headUrl);
        data.put("id", groupId);

        ObjectNodeResult objectNodeResult = Group.saveGroupByJson(me, data);

        if (!objectNodeResult.isSuccess()) {
            Logger.error(objectNodeResult.getObjectNode().toString());
            return ServiceVOResult.error("100001", "");
        }

        CommonVO vo = CommonVO.create();
        vo.set("headUrl", Assets.at(headUrl));

        ServiceVOResult<CommonVO> result = ServiceVOResult.success();
        result.setVo(vo);

        return result;
    }

    /**
     * <br>
     * ??
     *
     * @param groupId    Id
     * @param userIdList ?Idsize>0
     * @return
     */
    public static ServiceResult inviteJoinGroup(Long groupId, List<Long> userIdList) {
        if (null == groupId || CollectionUtils.isEmpty(userIdList)) {
            throw new IllegalArgumentException("groupId is null or userIdList is empty. groupId = " + groupId
                    + ", userIdList = " + userIdList);
        }

        User me = User.getFromSession(Context.current().session());
        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.NORMAL) {
            return ServiceResult.error("100005", "??");
        }
        if (null == group) {
            return ServiceResult.error("2001", "?");
        }
        List<Long> groupIdList = Arrays.asList(groupId);
        Map<Long, Boolean> checkJoinGroup = models.GroupMember.checkJoinGroup(me.getId(), groupIdList);
        if (checkJoinGroup.get(groupId) != true) {
            return ServiceResult.error("297001", "?");
        }

        Map<Long, Boolean> checkJoinGroupUser = models.GroupMember.checkJoinGroup(userIdList, groupId);

        for (Map.Entry<Long, Boolean> e : checkJoinGroupUser.entrySet()) {
            if (!e.getValue()) {
                User recevierUser = User.findById(e.getKey());
                if (null != recevierUser) {
                    MessageService.pushMsgInvitMember(me, recevierUser, group);
                }
            }
        }

        return ServiceResult.success();
    }

    /**
     * ?<br>
     * ???
     *
     * @param groupId    Id
     * @param userIdList ?Idsize>0
     * @return
     */
    public static ServiceResult inviteJoinMultiCommunicate(Long groupId, List<Long> userIdList) {
        if (null == groupId || CollectionUtils.isEmpty(userIdList)) {
            throw new IllegalArgumentException("groupId is null or userIdList is empty. groupId = " + groupId
                    + ", userIdList = " + userIdList);
        }

        User me = User.getFromSession(Context.current().session());
        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.MULTICOMMUNICATE) {
            return ServiceResult.error("100005", "???");
        }
        if (null == group) {
            return ServiceResult.error("2001", "?");
        }
        List<Long> groupIdList = Arrays.asList(groupId);
        Map<Long, Boolean> checkJoinGroup = models.GroupMember.checkJoinGroup(me.getId(), groupIdList);
        if (checkJoinGroup.get(groupId) != true) {
            return ServiceResult.error("309001", "??");
        }

        for (Long userId : userIdList) {
            Map<Long, Boolean> isJoinGroup = models.GroupMember.checkJoinGroup(userId, Arrays.asList(groupId));
            if (!isJoinGroup.get(groupId)) {
                try {
                    ChatService.appendMemberToGroup(groupId, userId);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        return ServiceResult.success();
    }

    /**
     * ??
     *
     * @param messageId ?Id
     * @return
     */
    public static ServiceResult agreeJoinGroupInvite(Long messageId) {
        User me = User.getFromSession(Context.current().session());

        Message message = Message.queryById(messageId);
        if (null == message || message.msgType != MsgType.INVIT_GROUP_MEMBER
                || !Objects.equals(message.consumeOnly, me.id.toString())) {
            return ServiceResult.error("100005", "?messageId = " + messageId);
        }

        User receiverUser = User.findById(NumberUtils.toLong(message.consumeOnly, -1));
        if (null == receiverUser) {
            LOGGER.error("invalid receiverId. message.content = " + message.content);
            return ServiceResult.error("100001", "");
        }

        JsonNode content = Json.parse(message.content);

        long groupId = content.get("groupId").asLong(-1);
        Group group = Group.queryGroupById(groupId);
        if (null == group) {
            LOGGER.error("invalid groupId. message.content = " + message.content);
            return ServiceResult.error("2001", "?");
        }
        List<Long> groupIdList = Arrays.asList(groupId);
        Map<Long, Boolean> checkJoinGroup = models.GroupMember.checkJoinGroup(receiverUser.getId(), groupIdList);
        if (checkJoinGroup.get(groupId) == true) {
            MessageService.handlerMessage(messageId);
            return ServiceResult.error("2003", "??");
        }

        User senderUser = User.findById(NumberUtils.toLong(message.senderOnly, -1));
        if (null == senderUser) {
            LOGGER.error("invalid senderId. message.content = " + message.content);
            return ServiceResult.error("100001", "");
        }

        try {
            ChatService.appendMemberToGroup(groupId, receiverUser.getId());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        MessageService.pushMsgInvitAgree(me, senderUser, group);
        MessageService.handlerMessage(messageId);
        return ServiceResult.success();
    }

    /**
     * 
     *
     * @param groupId Id
     * @return
     */
    public static ServiceResult joinPublicGroup(Long groupId) {
        User me = User.getFromSession(Context.current().session());
        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.NORMAL) {
            return ServiceResult.error("100005", "??");
        }
        if (null == group) {
            return ServiceResult.error("2001", "?");
        }
        if (group.getGroupPriv() != GroupPriv.PUBLIC) {
            return ServiceResult.error("299002", "??");
        }
        List<Long> groupIdList = Arrays.asList(groupId);
        Map<Long, Boolean> checkJoinGroup = models.GroupMember.checkJoinGroup(me.getId(), groupIdList);
        if (checkJoinGroup.get(groupId) == true) {
            return ServiceResult.error("299001", "??");
        }

        ObjectNodeResult result;
        try {
            result = models.service.ChatService.appendMemberToGroup(groupId, me.getId());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        return ServiceResult.create(result);
    }

    /**
     * ?
     *
     * @param groupId Id
     * @param content <=250
     * @return
     */
    public static ServiceResult applyJoinGroup(Long groupId, String content) {
        if (content.length() > 250) {
            return ServiceResult.error("100005", "?");
        }

        User me = User.getFromSession(Context.current().session());
        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.NORMAL) {
            return ServiceResult.error("100005", "??");
        }
        if (null == group) {
            return ServiceResult.error("2001", "?");
        }
        List<Long> groupIdList = Arrays.asList(groupId);
        Map<Long, Boolean> checkJoinGroup = models.GroupMember.checkJoinGroup(me.getId(), groupIdList);
        if (checkJoinGroup.get(groupId) == true) {
            return ServiceResult.error("300001", "??");
        }
        User recevierUser = User.findById(group.owner.userId);
        MessageService.pushMsgApply(me, recevierUser, group, content);
        return ServiceResult.success();
    }

    /**
     * ?
     *
     * @param groupId Id
     * @param userIds ?Id?
     * @return
     */
    public static ServiceResult removeGroupMember(Long groupId, List<Long> userIds) {
        User me = User.getFromSession(Context.current().session());

        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.NORMAL) {
            return ServiceResult.error("100005", "??");
        }
        if (null == group) {
            return ServiceResult.error("2001", "?");
        } else if (!Objects.equals(group.getOwner().getUserId(), me.getId())) {
            return ServiceResult.error("2002", "??");
        }

        JPA.em().clear();

        for (Long userId : userIds) {
            User user = User.findById(userId);
            if (null != user) {
                ObjectNodeResult objectNodeResult = ChatService.deleteMemberFromGroup(user, groupId, 1);
                if (!objectNodeResult.isSuccess() && !"900011".equals(objectNodeResult.getErrorCode())) {
                    Logger.error(objectNodeResult.getObjectNode().toString());
                    return ServiceResult.error("100001", "");

                }
            }
        }

        return ServiceResult.success();
    }

    /**
     * <br>
     * ?
     *
     * @param groupId Id
     * @return
     */
    public static ServiceResult quitGroup(Long groupId) {
        User me = User.getFromSession(Context.current().session());

        ObjectNodeResult objectNodeResult = ChatService.deleteMemberFromGroup(me, groupId, 2);

        if (!objectNodeResult.isSuccess()) {
            switch (objectNodeResult.getErrorCode()) {
            case "900010":
                return ServiceResult.error("100005", "groupId = " + groupId);
            case "900011":
                return ServiceResult.error("303001", "?");
            case "900105":
                return ServiceResult.error("303002", "?");
            default:
                Logger.error(objectNodeResult.getObjectNode().toString());
                return ServiceResult.error("100001", "");
            }

        }

        return ServiceResult.success();
    }

    /**
     * 
     *
     * @param groupId Id
     * @return
     */
    public static ServiceResult deleteGroup(Long groupId) {
        User me = User.getFromSession(Context.current().session());

        ObjectNodeResult objectNodeResult = ChatService.deleteGroup(me, groupId);

        if (!objectNodeResult.isSuccess()) {
            switch (objectNodeResult.getErrorCode()) {
            case "900103":
                return ServiceResult.error("100005", "groupId = " + groupId);
            case "900104":
                return ServiceResult.error("100005", "??");
            case "900105":
                return ServiceResult.error("304001", "??");
            default:
                Logger.error(objectNodeResult.getObjectNode().toString());
                return ServiceResult.error("100001", "");
            }

        }

        return ServiceResult.success();
    }

    /**
     * ??
     *
     * @param messageId ?Id
     * @return
     */
    public static ServiceResult agreeJoinGroupApply(Long messageId) {
        User me = User.getFromSession(Context.current().session());

        Message message = Message.queryById(messageId);
        if (null == message || message.msgType != MsgType.APPLY_GROUP
                || !Objects.equals(message.consumeOnly, me.id.toString())) {
            return ServiceResult.error("100005", "?messageId = " + messageId);
        }

        User senderUser = User.findById(NumberUtils.toLong(message.senderOnly, -1));
        if (null == senderUser) {
            LOGGER.error("invalid senderId. message.content = " + message.content);
            return ServiceResult.error("100001", "");
        }

        JsonNode content = Json.parse(message.content);

        long groupId = content.get("groupId").asLong(-1);
        Group group = Group.queryGroupById(groupId);
        if (null == group) {
            return ServiceResult.error("2001", "?");
        }
        List<Long> groupIdList = Arrays.asList(groupId);
        Map<Long, Boolean> checkJoinGroup = models.GroupMember.checkJoinGroup(senderUser.getId(), groupIdList);
        if (checkJoinGroup.get(groupId) == true) {
            MessageService.handlerMessage(messageId);
            return ServiceResult.error("2004", "??");
        }

        try {
            ChatService.appendMemberToGroup(groupId, senderUser.getId());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        MessageService.pushMsgApplyAgree(me, senderUser, group);
        MessageService.handlerMessage(messageId);
        return ServiceResult.success();
    }

    /**
     * ????
     *
     * @param groupId      Id
     * @param newGroupName ??
     * @return
     */
    public static ServiceResult updateGroupName(Long groupId, String newGroupName) {
        User me = User.getFromSession(Context.current().session());

        Group group = Group.queryGroupById(groupId);
        if (null != group && group.getType() != Group.Type.TRANSLATE
                && group.getType() != Group.Type.MULTICOMMUNICATE) {
            return ServiceResult.error("100005", "????");
        }
        if (null == group) {
            return ServiceResult.error("2001", "?");
        }
        List<Long> groupIdList = Arrays.asList(groupId);
        Map<Long, Boolean> checkJoinGroup = models.GroupMember.checkJoinGroup(me.getId(), groupIdList);
        if (checkJoinGroup.get(groupId) != true) {
            return ServiceResult.error("100005", "groupId = " + groupId);
        }

        ObjectNodeResult objectNodeResult;
        try {
            objectNodeResult = ChatService.updateMultiCommunicateName(me, newGroupName, groupId);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        if (!objectNodeResult.isSuccess()) {
            if ("900002".equals(objectNodeResult.getErrorCode())) {
                return ServiceResult.error("308001", objectNodeResult.getError());
            }
            Logger.error(objectNodeResult.getObjectNode().toString());
            return ServiceResult.error("100001", "");
        }
        return ServiceResult.success();
    }

}