예제 #1
0
파일: user.go 프로젝트: ovh/tat
// CheckDefaultGroup check default group and creates it if fixDefaultGroup is true
func CheckDefaultGroup(user *tat.User, fixDefaultGroup bool) string {
	defaultGroupInfo := ""

	userGroups, err := group.GetUserGroupsOnlyName(user.Username)
	if err != nil {
		return "Error while fetching user groups"
	}

	find := false
	for _, g := range userGroups {
		if g == viper.GetString("default_group") {
			find = true
			defaultGroupInfo = fmt.Sprintf("user in %s OK", viper.GetString("default_group"))
			break
		}
	}
	if !find {
		if fixDefaultGroup {
			if err = AddDefaultGroup(user); err != nil {
				return err.Error()
			}
			defaultGroupInfo = fmt.Sprintf("user added in default group %s", viper.GetString("default_group"))
		} else {
			defaultGroupInfo = fmt.Sprintf("user in default group %s KO", viper.GetString("default_group"))
		}
	}
	return defaultGroupInfo
}
예제 #2
0
파일: users.go 프로젝트: ovh/tat
// Me retrieves all information about me (exception information about Authentication)
func (*UsersController) Me(ctx *gin.Context) {
	var user = tat.User{}
	found, err := userDB.FindByUsername(&user, getCtxUsername(ctx))
	if !found {
		ctx.JSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
		return
	} else if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error while fetching user"})
		return
	}
	gs, errGetGroupsOnlyName := groupDB.GetUserGroupsOnlyName(user.Username)
	if errGetGroupsOnlyName != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error while getting groups"})
		return
	}
	user.Groups = gs
	out := &tat.UserJSON{User: user}
	ctx.JSON(http.StatusOK, out)
}
예제 #3
0
파일: user.go 프로젝트: ovh/tat
// ListUsers returns users list selected by criteria
func ListUsers(criteria *tat.UserCriteria, isAdmin bool) (int, []tat.User, error) {
	var users []tat.User

	cursor, errl := listUsersCursor(criteria, isAdmin)
	if errl != nil {
		return -1, users, errl
	}
	count, err := cursor.Count()
	if err != nil {
		return -1, users, fmt.Errorf("Error while count Users %s", err)
	}

	sortBy := criteria.SortBy
	if sortBy == "" {
		sortBy = "-dateCreation"
	}
	err = cursor.Select(getUserListField(isAdmin)).
		Sort(sortBy).
		Skip(criteria.Skip).
		Limit(criteria.Limit).
		All(&users)

	if err != nil {
		return -1, users, fmt.Errorf("Error while Find All Users %s", err)
	}

	// Admin could ask groups for all users. Not perf, but really rare
	if criteria.WithGroups && isAdmin {
		var usersWithGroups []tat.User
		for _, u := range users {
			gs, errGetGroupsOnlyName := group.GetUserGroupsOnlyName(u.Username)
			u.Groups = gs
			log.Infof("User %s, Groups%s", u.Username, u.Groups)
			if errGetGroupsOnlyName != nil {
				log.Errorf("Error while getting group for user %s, Error:%s", u.Username, errGetGroupsOnlyName)
			}
			usersWithGroups = append(usersWithGroups, u)
		}
		return count, usersWithGroups, nil
	}
	return count, users, err
}
예제 #4
0
파일: topic.go 프로젝트: ovh/tat
func buildTopicCriteria(criteria *tat.TopicCriteria, user *tat.User) (bson.M, error) {
	var query = []bson.M{}

	if criteria.IDTopic != "" {
		queryIDTopics := bson.M{}
		queryIDTopics["$or"] = []bson.M{}
		for _, val := range strings.Split(criteria.IDTopic, ",") {
			queryIDTopics["$or"] = append(queryIDTopics["$or"].([]bson.M), bson.M{"_id": val})
		}
		query = append(query, queryIDTopics)
	}
	if criteria.Topic != "" || criteria.OnlyFavorites == tat.True {
		queryTopics := bson.M{}
		queryTopics["$or"] = []bson.M{}
		for _, val := range strings.Split(criteria.Topic, ",") {
			queryTopics["$or"] = append(queryTopics["$or"].([]bson.M), bson.M{"topic": val})
		}
		query = append(query, queryTopics)
	}
	if criteria.TopicPath != "" {
		query = append(query, bson.M{"topic": bson.RegEx{Pattern: "^" + regexp.QuoteMeta(criteria.TopicPath) + ".*$", Options: "im"}})
	}
	if criteria.Description != "" {
		queryDescriptions := bson.M{}
		queryDescriptions["$or"] = []bson.M{}
		for _, val := range strings.Split(criteria.Description, ",") {
			queryDescriptions["$or"] = append(queryDescriptions["$or"].([]bson.M), bson.M{"description": val})
		}
		query = append(query, queryDescriptions)
	}
	if criteria.Group != "" {
		queryGroups := bson.M{}
		queryGroups["$or"] = []bson.M{}
		queryGroups["$or"] = append(queryGroups["$or"].([]bson.M), bson.M{"adminGroups": bson.M{"$in": strings.Split(criteria.Group, ",")}})
		queryGroups["$or"] = append(queryGroups["$or"].([]bson.M), bson.M{"roGroups": bson.M{"$in": strings.Split(criteria.Group, ",")}})
		queryGroups["$or"] = append(queryGroups["$or"].([]bson.M), bson.M{"rwGroups": bson.M{"$in": strings.Split(criteria.Group, ",")}})
		query = append(query, queryGroups)
	}

	var bsonDate = bson.M{}

	if criteria.DateMinCreation != "" {
		i, err := strconv.ParseInt(criteria.DateMinCreation, 10, 64)
		if err != nil {
			return bson.M{}, fmt.Errorf("Error while parsing dateMinCreation %s", err)
		}
		tm := time.Unix(i, 0)
		bsonDate["$gte"] = tm.Unix()
	}
	if criteria.DateMaxCreation != "" {
		i, err := strconv.ParseInt(criteria.DateMaxCreation, 10, 64)
		if err != nil {
			return bson.M{}, fmt.Errorf("Error while parsing dateMaxCreation %s", err)
		}
		tm := time.Unix(i, 0)
		bsonDate["$lte"] = tm.Unix()
	}
	if len(bsonDate) > 0 {
		query = append(query, bson.M{"dateCreation": bsonDate})
	}

	if user != nil {
		if criteria.GetForAllTasksTopics {
			query = append(query, bson.M{
				"topic": bson.RegEx{Pattern: "^\\/Private\\/.*/Tasks", Options: "i"},
			})
		} else if criteria.GetForTatAdmin == tat.True && user.IsAdmin {
			// requester is tat Admin and wants all topics, except /Private/* topics
			query = append(query, bson.M{
				"topic": bson.M{"$not": bson.RegEx{Pattern: "^\\/Private\\/.*", Options: "i"}},
			})
		} else if criteria.GetForTatAdmin == tat.True && !user.IsAdmin {
			log.Warnf("User %s (not a TatAdmin) try to list all topics as an admin", user.Username)
		} else {
			bsonUser := []bson.M{}
			bsonUser = append(bsonUser, bson.M{"roUsers": bson.M{"$in": [1]string{user.Username}}})
			bsonUser = append(bsonUser, bson.M{"rwUsers": bson.M{"$in": [1]string{user.Username}}})
			bsonUser = append(bsonUser, bson.M{"adminUsers": bson.M{"$in": [1]string{user.Username}}})
			userGroups, err := group.GetUserGroupsOnlyName(user.Username)
			if err != nil {
				log.Errorf("Error with getting groups for user %s", err)
			} else {
				bsonUser = append(bsonUser, bson.M{"roGroups": bson.M{"$in": userGroups}})
				bsonUser = append(bsonUser, bson.M{"rwGroups": bson.M{"$in": userGroups}})
				bsonUser = append(bsonUser, bson.M{"adminGroups": bson.M{"$in": userGroups}})
			}
			query = append(query, bson.M{"$or": bsonUser})
		}
	}

	if len(query) > 0 {
		return bson.M{"$and": query}, nil
	} else if len(query) == 1 {
		return query[0], nil
	}
	return bson.M{}, nil
}