Python APIDB.get_club_members方法代码示例

# 需要导入模块: from api_db_utils import APIDB [as 别名]
# 或者: from api_db_utils.APIDB import get_club_members [as 别名]
def trainee_club_details(req, uskey_club):
    """
    ``GET`` @ |ta| +  ``/clubs/<uskey_club>``

    Detail of a club
    """
    club = req.model
    j_club = club.to_dict()
    j_club['member_count'] = APIDB.get_club_members(club, count_only=True)
    j_club['courses'] = sanitize_list(APIDB.get_club_courses(club),
                                      ['id', 'name', 'start_date', 'end_date', 'course_type'])
    j_club['owners'] = sanitize_list(APIDB.get_club_owners(club), ['name', 'picture'])
    return sanitize_json(j_club, ['id', 'name', 'description', 'url', 'creation_date', 'is_open', 'owners',
                                  'member_count', 'courses'])

# 需要导入模块: from api_db_utils import APIDB [as 别名]
# 或者: from api_db_utils.APIDB import get_club_members [as 别名]
def coach_club_list(req):
    """
    ``GET`` @ |ta| +  ``/clubs``

    List of the clubs
    """
    # check if there's the filter
    user = req.user
    j_req = json_from_paginated_request(req, (('paginated', 'true'),))
    page = int(j_req['page'])
    size = int(j_req['size'])
    paginated = j_req['paginated'] == 'true'

    # if paginated then use the pagination..
    if paginated:
        clubs, total = APIDB.get_user_owner_or_trainer_of(user, paginated=True, page=page, size=size)
    else:
        clubs = APIDB.get_user_owner_or_trainer_of(user)
    # render accordingly to the doc.
    ret = {}
    items = []
    for club in clubs:
        if not club.is_deleted:
            j_club = club.to_dict()
            j_club['role'] = club.membership.membership_type
            j_club['member_count'] = APIDB.get_club_members(club, count_only=True)
            j_club['course_count'] = APIDB.get_club_courses(club, count_only=True)
            j_club['owner_count'] = APIDB.get_club_owners(club, count_only=True)
            j_club['trainer_count'] = APIDB.get_club_trainers(club, count_only=True)
            # j_club['owners'] = sanitize_list(APIDB.get_club_owners(club), ['id','name', 'picture'])
            items.append(j_club)
            j_club['trainers'] = sanitize_list(APIDB.get_club_trainers(club), ['id', 'name', 'picture'])

    if paginated:
        ret['results'] = sanitize_list(items,
                                       ['id', 'name', 'description', 'url', 'creation_date', 'is_open', 'tags',
                                        'owner_count', 'trainer_count',
                                        'member_count', 'course_count', 'trainers', 'role'])
        ret['total'] = total
        return ret
    else:
        return sanitize_list(items,
                             ['id', 'name', 'description', 'url', 'creation_date', 'is_open', 'tags', 'owner_count',
                              'trainer_count',
                              'member_count', 'course_count', 'trainers', 'role'])

# 需要导入模块: from api_db_utils import APIDB [as 别名]
# 或者: from api_db_utils.APIDB import get_club_members [as 别名]
def trainee_club_members(req, uskey_club):
    """
    ``GET`` @ |ta| +  ``/clubs/<uskey_club>/members``

    List of the members of a club
    """
    club = req.model
    if uskey_club == "current":
        user = GCAuth.get_user(req)
        if APIDB.get_user_club_role(user, club) != "MEMBER":
            raise AuthenticationError("User is not subscribed to the course")
    j_req = json_from_paginated_request(req)
    page = int(j_req['page'])
    size = int(j_req['size'])
    role = req.get('role', None)
    status = req.get('status', "ACCEPTED")
    l_users = []
    if not role:
        members, total = APIDB.get_club_all_members(club, status=status, paginated=True, page=page, size=size,
                                                    merge="role")
    elif role == "MEMBER":
        members, total = APIDB.get_club_members(club, status=status, paginated=True, page=page, size=size)
    elif role == "TRAINER":
        members, total = APIDB.get_club_trainers(club, status=status, paginated=True, page=page, size=size)
    elif role == "OWNER":
        members, total = APIDB.get_club_owners(club, status=status, paginated=True, page=page, size=size)
    # if the query is paginated, and the previous call has already fetched enough people.
    else:
        raise BadParameters("Role does not exists %s" % role)

    for member in members:
        user_role = role
        if not user_role:
            # this is not very efficent.. but works
            user_role = member.role.membership_type
        if user_role == "MEMBER":
            res_user = sanitize_json(member, allowed=["nickname", "avatar", "id"])
        elif user_role == "TRAINER":
            res_user = sanitize_json(member, allowed=["name", "picture", "id"])
        elif user_role == "OWNER":
            res_user = sanitize_json(member, allowed=["name", "picture", "id"])
        res_user['type'] = user_role
        l_users.append(res_user)

    return dict(results=l_users, total=total)

# 需要导入模块: from api_db_utils import APIDB [as 别名]
# 或者: from api_db_utils.APIDB import get_club_members [as 别名]
def trainee_club_list(req):
    """
    ``GET`` @ |ta| +  ``/clubs``

    List of the clubs
    """
    # check if there's the filter
    j_req = json_from_paginated_request(req, (('member', None),))
    if hasattr(req, 'member'):
        j_req['member'] = req.member
    user_filter = j_req['member'] == 'true'
    page = int(j_req['page'])
    size = int(j_req['size'])

    # if user and filter are true, then get from the clubs he's member of
    if user_filter:
        # get the user, just in case
        user = GCAuth.get_user_or_none(req)
        if user:
            clubs, total = APIDB.get_user_member_of(user, paginated=True, page=page, size=size)
        else:
            raise AuthenticationError("member is set but user is missing")
    else:
        clubs, total = APIDB.get_clubs(paginated=True, page=page, size=size)

    # render accordingly to the doc.
    ret = {}
    items = []
    for club in clubs:
        if not club.is_deleted:
            j_club = club.to_dict()
            j_club['member_count'] = APIDB.get_club_members(club, count_only=True)
            j_club['course_count'] = APIDB.get_club_courses(club, count_only=True)
            j_club['owners'] = sanitize_list(APIDB.get_club_owners(club), ['name', 'picture'])
            items.append(j_club)
    ret['results'] = sanitize_list(items,
                                   ['id', 'name', 'description', 'url', 'creation_date', 'is_open', 'tags', 'owners',
                                    'member_count', 'course_count'])

    ret['total'] = total
    return ret