1 files changed, 350 insertions, 2 deletions

diff --git a/app/team.go b/app/team.go
index 495e0773f..28d667268 100644
--- a/app/team.go
+++ b/app/team.go
@@ -4,6 +4,11 @@
 package app
 
 import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+
 	l4g "github.com/alecthomas/log4go"
 
 	"github.com/mattermost/platform/model"
@@ -24,6 +29,57 @@ func CreateTeam(team *model.Team) (*model.Team, *model.AppError) {
 	}
 }
 
+func UpdateTeam(team *model.Team) (*model.Team, *model.AppError) {
+	var oldTeam *model.Team
+	var err *model.AppError
+	if oldTeam, err = GetTeam(team.Id); err != nil {
+		return nil, err
+	}
+
+	oldTeam.DisplayName = team.DisplayName
+	oldTeam.Description = team.Description
+	oldTeam.InviteId = team.InviteId
+	oldTeam.AllowOpenInvite = team.AllowOpenInvite
+	oldTeam.CompanyName = team.CompanyName
+	oldTeam.AllowedDomains = team.AllowedDomains
+
+	if result := <-Srv.Store.Team().Update(oldTeam); result.Err != nil {
+		return nil, result.Err
+	}
+
+	return oldTeam, nil
+}
+
+func UpdateTeamMemberRoles(teamId string, userId string, newRoles string) (*model.TeamMember, *model.AppError) {
+	var member *model.TeamMember
+	if result := <-Srv.Store.Team().GetTeamsForUser(userId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		members := result.Data.([]*model.TeamMember)
+		for _, m := range members {
+			if m.TeamId == teamId {
+				member = m
+			}
+		}
+	}
+
+	if member == nil {
+		err := model.NewLocAppError("UpdateTeamMemberRoles", "api.team.update_member_roles.not_a_member", nil, "userId="+userId+" teamId="+teamId)
+		err.StatusCode = http.StatusBadRequest
+		return nil, err
+	}
+
+	member.Roles = newRoles
+
+	if result := <-Srv.Store.Team().UpdateMember(member); result.Err != nil {
+		return nil, result.Err
+	}
+
+	ClearSessionCacheForUser(userId)
+
+	return member, nil
+}
+
 func JoinUserToTeamById(teamId string, user *model.User) *model.AppError {
 	if result := <-Srv.Store.Team().Get(teamId); result.Err != nil {
 		return result.Err
@@ -32,6 +88,55 @@ func JoinUserToTeamById(teamId string, user *model.User) *model.AppError {
 	}
 }
 
+func JoinUserToTeamByHash(userId string, hash string, data string) (*model.Team, *model.AppError) {
+	props := model.MapFromJson(strings.NewReader(data))
+
+	if !model.ComparePassword(hash, fmt.Sprintf("%v:%v", data, utils.Cfg.EmailSettings.InviteSalt)) {
+		return nil, model.NewLocAppError("JoinUserToTeamByHash", "api.user.create_user.signup_link_invalid.app_error", nil, "")
+	}
+
+	t, timeErr := strconv.ParseInt(props["time"], 10, 64)
+	if timeErr != nil || model.GetMillis()-t > 1000*60*60*48 { // 48 hours
+		return nil, model.NewLocAppError("JoinUserToTeamByHash", "api.user.create_user.signup_link_expired.app_error", nil, "")
+	}
+
+	var team *model.Team
+	var err *model.AppError
+	if team, err = GetTeam(props["id"]); err != nil {
+		return nil, err
+	}
+
+	var user *model.User
+	if user, err = GetUser(userId); err != nil {
+		return nil, err
+	}
+
+	if err := JoinUserToTeam(team, user); err != nil {
+		return nil, err
+	}
+
+	return team, nil
+}
+
+func JoinUserToTeamByInviteId(inviteId string, userId string) (*model.Team, *model.AppError) {
+	var team *model.Team
+	var err *model.AppError
+	if team, err = GetTeamByInviteId(inviteId); err != nil {
+		return nil, err
+	}
+
+	var user *model.User
+	if user, err = GetUser(userId); err != nil {
+		return nil, err
+	}
+
+	if err := JoinUserToTeam(team, user); err != nil {
+		return nil, err
+	}
+
+	return team, nil
+}
+
 func JoinUserToTeam(team *model.Team, user *model.User) *model.AppError {
 
 	tm := &model.TeamMember{
@@ -49,7 +154,7 @@ func JoinUserToTeam(team *model.Team, user *model.User) *model.AppError {
 
 	if etmr := <-Srv.Store.Team().GetMember(team.Id, user.Id); etmr.Err == nil {
 		// Membership alredy exists.  Check if deleted and and update, otherwise do nothing
-		rtm := etmr.Data.(model.TeamMember)
+		rtm := etmr.Data.(*model.TeamMember)
 
 		// Do nothing if already added
 		if rtm.DeleteAt == 0 {
@@ -75,12 +180,52 @@ func JoinUserToTeam(team *model.Team, user *model.User) *model.AppError {
 		l4g.Error(utils.T("api.user.create_user.joining.error"), user.Id, team.Id, err)
 	}
 
-	RemoveAllSessionsForUserId(user.Id)
+	ClearSessionCacheForUser(user.Id)
 	InvalidateCacheForUser(user.Id)
 
 	return nil
 }
 
+func GetTeam(teamId string) (*model.Team, *model.AppError) {
+	if result := <-Srv.Store.Team().Get(teamId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.Team), nil
+	}
+}
+
+func GetTeamByName(name string) (*model.Team, *model.AppError) {
+	if result := <-Srv.Store.Team().GetByName(name); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.Team), nil
+	}
+}
+
+func GetTeamByInviteId(inviteId string) (*model.Team, *model.AppError) {
+	if result := <-Srv.Store.Team().GetByInviteId(inviteId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.Team), nil
+	}
+}
+
+func GetAllTeams() ([]*model.Team, *model.AppError) {
+	if result := <-Srv.Store.Team().GetAll(); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.([]*model.Team), nil
+	}
+}
+
+func GetAllOpenTeams() ([]*model.Team, *model.AppError) {
+	if result := <-Srv.Store.Team().GetAllTeamListing(); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.([]*model.Team), nil
+	}
+}
+
 func GetTeamsForUser(userId string) ([]*model.Team, *model.AppError) {
 	if result := <-Srv.Store.Team().GetTeamsByUserId(userId); result.Err != nil {
 		return nil, result.Err
@@ -88,3 +233,206 @@ func GetTeamsForUser(userId string) ([]*model.Team, *model.AppError) {
 		return result.Data.([]*model.Team), nil
 	}
 }
+
+func GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
+	if result := <-Srv.Store.Team().GetMember(teamId, userId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.(*model.TeamMember), nil
+	}
+}
+
+func GetTeamMembersForUser(userId string) ([]*model.TeamMember, *model.AppError) {
+	if result := <-Srv.Store.Team().GetTeamsForUser(userId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.([]*model.TeamMember), nil
+	}
+}
+
+func GetTeamMembers(teamId string, offset int, limit int) ([]*model.TeamMember, *model.AppError) {
+	if result := <-Srv.Store.Team().GetMembers(teamId, offset, limit); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.([]*model.TeamMember), nil
+	}
+}
+
+func GetTeamMembersByIds(teamId string, userIds []string) ([]*model.TeamMember, *model.AppError) {
+	if result := <-Srv.Store.Team().GetMembersByIds(teamId, userIds); result.Err != nil {
+		return nil, result.Err
+	} else {
+		return result.Data.([]*model.TeamMember), nil
+	}
+}
+
+func LeaveTeam(team *model.Team, user *model.User) *model.AppError {
+	var teamMember *model.TeamMember
+	var err *model.AppError
+
+	if teamMember, err = GetTeamMember(team.Id, user.Id); err != nil {
+		return model.NewLocAppError("LeaveTeam", "api.team.remove_user_from_team.missing.app_error", nil, err.Error())
+	}
+
+	var channelList *model.ChannelList
+
+	if result := <-Srv.Store.Channel().GetChannels(team.Id, user.Id); result.Err != nil {
+		if result.Err.Id == "store.sql_channel.get_channels.not_found.app_error" {
+			channelList = &model.ChannelList{}
+		} else {
+			return result.Err
+		}
+
+	} else {
+		channelList = result.Data.(*model.ChannelList)
+	}
+
+	for _, channel := range *channelList {
+		if channel.Type != model.CHANNEL_DIRECT {
+			InvalidateCacheForChannel(channel.Id)
+			if result := <-Srv.Store.Channel().RemoveMember(channel.Id, user.Id); result.Err != nil {
+				return result.Err
+			}
+		}
+	}
+
+	// Send the websocket message before we actually do the remove so the user being removed gets it.
+	message := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_LEAVE_TEAM, team.Id, "", "", nil)
+	message.Add("user_id", user.Id)
+	message.Add("team_id", team.Id)
+	Publish(message)
+
+	teamMember.Roles = ""
+	teamMember.DeleteAt = model.GetMillis()
+
+	if result := <-Srv.Store.Team().UpdateMember(teamMember); result.Err != nil {
+		return result.Err
+	}
+
+	if uua := <-Srv.Store.User().UpdateUpdateAt(user.Id); uua.Err != nil {
+		return uua.Err
+	}
+
+	// delete the preferences that set the last channel used in the team and other team specific preferences
+	if result := <-Srv.Store.Preference().DeleteCategory(user.Id, team.Id); result.Err != nil {
+		return result.Err
+	}
+
+	ClearSessionCacheForUser(user.Id)
+	InvalidateCacheForUser(user.Id)
+
+	return nil
+}
+
+func InviteNewUsersToTeam(emailList []string, teamId, senderId, siteURL string) *model.AppError {
+	tchan := Srv.Store.Team().Get(teamId)
+	uchan := Srv.Store.User().Get(senderId)
+
+	var team *model.Team
+	if result := <-tchan; result.Err != nil {
+		return result.Err
+	} else {
+		team = result.Data.(*model.Team)
+	}
+
+	var user *model.User
+	if result := <-uchan; result.Err != nil {
+		return result.Err
+	} else {
+		user = result.Data.(*model.User)
+	}
+
+	SendInviteEmails(team, user.GetDisplayName(), emailList, siteURL)
+
+	return nil
+}
+
+func FindTeamByName(name string) bool {
+	if result := <-Srv.Store.Team().GetByName(name); result.Err != nil {
+		return false
+	} else {
+		return true
+	}
+}
+
+func GetTeamsUnreadForUser(teamId string, userId string) ([]*model.TeamUnread, *model.AppError) {
+	if result := <-Srv.Store.Team().GetTeamsUnreadForUser(teamId, userId); result.Err != nil {
+		return nil, result.Err
+	} else {
+		data := result.Data.([]*model.ChannelUnread)
+		var members []*model.TeamUnread
+		membersMap := make(map[string]*model.TeamUnread)
+
+		unreads := func(cu *model.ChannelUnread, tu *model.TeamUnread) *model.TeamUnread {
+			tu.MentionCount += cu.MentionCount
+
+			if cu.NotifyProps["mark_unread"] != model.CHANNEL_MARK_UNREAD_MENTION {
+				tu.MsgCount += (cu.TotalMsgCount - cu.MsgCount)
+			}
+
+			return tu
+		}
+
+		for i := range data {
+			id := data[i].TeamId
+			if mu, ok := membersMap[id]; ok {
+				membersMap[id] = unreads(data[i], mu)
+			} else {
+				membersMap[id] = unreads(data[i], &model.TeamUnread{
+					MsgCount:     0,
+					MentionCount: 0,
+					TeamId:       id,
+				})
+			}
+		}
+
+		for _, val := range membersMap {
+			members = append(members, val)
+		}
+
+		return members, nil
+	}
+}
+
+func PermanentDeleteTeam(team *model.Team) *model.AppError {
+	team.DeleteAt = model.GetMillis()
+	if result := <-Srv.Store.Team().Update(team); result.Err != nil {
+		return result.Err
+	}
+
+	if result := <-Srv.Store.Channel().PermanentDeleteByTeam(team.Id); result.Err != nil {
+		return result.Err
+	}
+
+	if result := <-Srv.Store.Team().RemoveAllMembersByTeam(team.Id); result.Err != nil {
+		return result.Err
+	}
+
+	if result := <-Srv.Store.Team().PermanentDelete(team.Id); result.Err != nil {
+		return result.Err
+	}
+
+	return nil
+}
+
+func GetTeamStats(teamId string) (*model.TeamStats, *model.AppError) {
+	tchan := Srv.Store.Team().GetTotalMemberCount(teamId)
+	achan := Srv.Store.Team().GetActiveMemberCount(teamId)
+
+	stats := &model.TeamStats{}
+	stats.TeamId = teamId
+
+	if result := <-tchan; result.Err != nil {
+		return nil, result.Err
+	} else {
+		stats.TotalMemberCount = result.Data.(int64)
+	}
+
+	if result := <-achan; result.Err != nil {
+		return nil, result.Err
+	} else {
+		stats.ActiveMemberCount = result.Data.(int64)
+	}
+
+	return stats, nil
+}