Exemple #1
0
// IsUserAdmin return true if user is Tat admin or is admin on this topic
// Check personal access to topic, and group access
func (topic *Topic) IsUserAdmin(user *User) bool {

	if user.IsAdmin {
		return true
	}

	if utils.ArrayContains(topic.AdminUsers, user.Username) {
		return true
	}

	userGroups, err := user.GetGroups()
	if err != nil {
		log.Errorf("Error while fetching user groups")
		return false
	}

	var groups []string
	for _, g := range userGroups {
		groups = append(groups, g.Name)
	}

	if utils.ItemInBothArrays(topic.AdminGroups, groups) {
		return true
	}

	// user is "Admin" on his /Private/usrname topics
	if strings.HasPrefix(topic.Topic, "/Private/"+user.Username) {
		return true
	}

	return false
}
Exemple #2
0
func initTree(messages []Message, criteria *MessageCriteria) ([]Message, error) {
	var ids []string
	idMessages := ""
	for i := 0; i <= len(messages)-1; i++ {
		if utils.ArrayContains(ids, messages[i].ID) {
			continue
		}
		ids = append(ids, messages[i].ID)
		idMessages += messages[i].ID + ","
	}

	if idMessages == "" {
		return messages, nil
	}

	c := &MessageCriteria{
		AllIDMessage: idMessages[:len(idMessages)-1],
		NotLabel:     criteria.NotLabel,
		NotTag:       criteria.NotTag,
	}
	var msgs []Message
	err := Store().clMessages.Find(buildMessageCriteria(c)).Sort("-dateCreation").All(&msgs)
	if err != nil {
		log.Errorf("Error while Find Messages in getTree %s", err)
		return messages, err
	}
	return msgs, nil
}
Exemple #3
0
// List returns the list of topics that can be viewed by user
func (t *TopicsController) List(ctx *gin.Context) {
	criteria := t.buildCriteria(ctx)
	var user = &models.User{}
	err := user.FindByUsername(utils.GetCtxUsername(ctx))
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error while fetching user."})
		return
	}
	count, topics, err := models.ListTopics(criteria, user)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error while fetching topics."})
		return
	}

	out := &topicsJSON{Topics: topics, Count: count}

	if criteria.GetNbMsgUnread == "true" {
		c := &models.PresenceCriteria{
			Username: user.Username,
		}
		count, presences, err := models.ListPresencesAllFields(c)
		if err != nil {
			ctx.AbortWithError(http.StatusInternalServerError, err)
			return
		}

		unread := make(map[string]int)
		knownPresence := false
		for _, topic := range topics {
			if utils.ArrayContains(user.OffNotificationsTopics, topic.Topic) {
				continue
			}
			knownPresence = false
			for _, presence := range presences {
				if topic.Topic != presence.Topic {
					continue
				}
				knownPresence = true

				nb, err := models.CountMsgSinceDate(presence.Topic, presence.DatePresence)
				if err != nil {
					ctx.JSON(http.StatusInternalServerError, err)
					return
				}
				unread[presence.Topic] = nb
			}
			if !knownPresence {
				unread[topic.Topic] = -1
			}
		}
		out.TopicsMsgUnread = unread
		out.CountTopicsMsgUnread = count
	}
	ctx.JSON(http.StatusOK, out)
}
Exemple #4
0
// IsUserReadAccess  return true if user has read access to topic
func (topic *Topic) IsUserReadAccess(user User) bool {
	currentTopic := topic

	if topic.IsROPublic {
		return true
	}

	// if user not admin, reload topic with admin rights
	if !user.IsAdmin {
		currentTopic = &Topic{}
		e := currentTopic.FindByID(topic.ID, true)
		if e != nil {
			return false
		}
	}

	if utils.ArrayContains(currentTopic.ROUsers, user.Username) ||
		utils.ArrayContains(currentTopic.RWUsers, user.Username) ||
		utils.ArrayContains(currentTopic.AdminUsers, user.Username) {
		return true
	}
	userGroups, err := user.GetGroups()
	if err != nil {
		log.Errorf("Error while fetching user groups for user %s", user.Username)
		return false
	}

	var groups []string
	for _, g := range userGroups {
		groups = append(groups, g.Name)
	}

	if utils.ItemInBothArrays(currentTopic.RWGroups, groups) ||
		utils.ItemInBothArrays(currentTopic.ROGroups, groups) ||
		utils.ItemInBothArrays(currentTopic.AdminGroups, groups) {
		return true
	}

	return false
}
Exemple #5
0
// IsUserRW return true if user can write on a this topic
// Check personal access to topic, and group access
func (topic *Topic) IsUserRW(user *User) bool {
	if utils.ArrayContains(topic.RWUsers, user.Username) ||
		utils.ArrayContains(topic.AdminUsers, user.Username) {
		return true
	}
	userGroups, err := user.GetGroups()
	if err != nil {
		log.Errorf("Error while fetching user groups")
		return false
	}

	var groups []string
	for _, g := range userGroups {
		groups = append(groups, g.Name)
	}

	if utils.ItemInBothArrays(topic.RWGroups, groups) {
		return true
	}

	return false
}
Exemple #6
0
// Unlike removes a like from one message
func (message *Message) Unlike(user User) error {
	if !utils.ArrayContains(message.Likers, user.Username) {
		return fmt.Errorf("Unlike not possible, %s is not a liker of this message", user.Username)
	}
	err := Store().clMessages.Update(
		bson.M{"_id": message.ID},
		bson.M{"$set": bson.M{"dateUpdate": time.Now().Unix()},
			"$inc":  bson.M{"nbLikes": -1},
			"$pull": bson.M{"likers": user.Username}})

	if err != nil {
		return err
	}
	return nil
}
Exemple #7
0
func fullTreeMessages(messages []Message, nloop int, criteria *MessageCriteria) ([]Message, error) {
	var tree []Message
	if nloop > 10 {
		e := "Infinite loop detected in fullTreeMessages"
		log.Errorf(e)
		return tree, errors.New(e)
	}

	replies := make(map[string][]Message)
	var alreadyDone []string

	for i := 0; i <= len(messages)-1; i++ {
		if utils.ArrayContains(alreadyDone, messages[i].ID) {
			continue
		}

		var replyAdded = false
		for _, msgReply := range replies[messages[i].ID] {
			messages[i].Replies = append(messages[i].Replies, msgReply)
			delete(replies, messages[i].ID)
			replyAdded = true
		}
		if messages[i].InReplyOfIDRoot == "" {
			if replyAdded || nloop > 1 {
				tree = append(tree, messages[i])
			} else if nloop == 1 && !replyAdded {
				replies[messages[i].ID] = append(replies[messages[i].ID], messages[i])
			}
			continue
		}
		replies[messages[i].InReplyOfID] = append(replies[messages[i].InReplyOfID], messages[i])
		alreadyDone = append(alreadyDone, messages[i].ID)
	}

	if len(replies) == 0 {
		return tree, nil
	}
	t, err := getTree(replies, criteria)
	if err != nil {
		return tree, err
	}
	ft, err := fullTreeMessages(t, nloop+1, criteria)
	return append(ft, tree...), err
}
Exemple #8
0
// IsUserAdmin return true if user is admin on this group
func (group *Group) IsUserAdmin(user *User) bool {
	if utils.ArrayContains(group.AdminUsers, user.Username) {
		return true
	}
	return false
}