def organisation_list(request, offset=None, limit=None, organisation_ids=None, *args, **kwargs): """ :param request: An HttpRequest :param offset: (optional) An optional query parameter specifying the offset in the result set to start from. :type offset: integer :param limit: (optional) An optional query parameter to limit the number of results returned. :type limit: integer :param organisation_ids: (optional) An optional list of organisation ids :type organisation_ids: array """ offset = int(offset if offset else settings.DEFAULT_LISTING_OFFSET) limit = check_limit(limit) organisations = Organisation.objects.order_by("id") if organisation_ids: organisations = organisations.filter(id__in=organisation_ids) organisations = organisations.annotate( x_total_count=RawSQL("COUNT(*) OVER ()", []))[offset:offset + limit] return ([ strip_empty_optional_fields( to_dict_with_custom_fields(organisation, ORGANISATION_VALUES)) for organisation in organisations ], { "X-Total-Count": organisations[0].x_total_count if organisations else 0 })
def country_list(request, offset=None, limit=None, country_codes=None, *args, **kwargs): """ :param request: An HttpRequest :param offset: (optional) An optional query parameter specifying the offset in the result set to start from. :type offset: integer :param limit: (optional) An optional query parameter to limit the number of results returned. :type limit: integer :param country_codes: (optional) An optional list of country codes :type country_codes: array """ offset = int(offset if offset else settings.DEFAULT_LISTING_OFFSET) limit = check_limit(limit) countries = Country.objects.order_by("code") if country_codes: countries = countries.filter(code__in=country_codes) countries = countries.annotate( x_total_count=RawSQL("COUNT(*) OVER ()", []))[offset:offset + limit] return ([ strip_empty_optional_fields( to_dict_with_custom_fields(country, COUNTRY_VALUES)) for country in countries ], { "X-Total-Count": countries[0].x_total_count if countries else 0 })
def client_read(request, client_id, *args, **kwargs): """ :param request: An HttpRequest :param client_id: A string value identifying the client :type client_id: string """ client = get_object_or_404(Client, id=client_id) result = to_dict_with_custom_fields(client, CLIENT_VALUES) return strip_empty_optional_fields(result)
def user_read(request, user_id, *args, **kwargs): """ :param request: An HttpRequest :param user_id: A UUID value identifying the user. :type user_id: string """ user = get_object_or_404(CoreUser, id=user_id) result = to_dict_with_custom_fields(user, USER_VALUES) return strip_empty_optional_fields(result)
def organisation_read(request, organisation_id, *args, **kwargs): """ :param request: An HttpRequest :param organisation_id: An integer identifying an organisation a user belongs to :type organisation_id: integer """ organisation = get_object_or_404(Organisation, id=organisation_id) result = to_dict_with_custom_fields(organisation, ORGANISATION_VALUES) return strip_empty_optional_fields(result)
def organisation_create(request, body, *args, **kwargs): """ :param request: An HttpRequest :param body: A dictionary containing the parsed and validated body :type body: dict """ organisation = Organisation.objects.create(**body) result = to_dict_with_custom_fields(organisation, ORGANISATION_VALUES) return strip_empty_optional_fields(result)
def country_read(request, country_code, *args, **kwargs): """ :param request: An HttpRequest :param country_code: A string value identifying the country :type country_code: string """ country = get_object_or_404(Country, code=country_code) result = to_dict_with_custom_fields(country, COUNTRY_VALUES) return strip_empty_optional_fields(result)
def user_update(request, body, user_id, *args, **kwargs): """ :param request: An HttpRequest :param body: A dictionary containing the parsed and validated body :type body: dict :param user_id: A UUID value identifying the user. :type user_id: string """ instance = get_object_or_404(CoreUser, id=user_id) for attr, value in body.items(): try: setattr(instance, attr, value) except Exception as e: LOGGER.error("Failed to set user attribute %s: %s" % (attr, e)) instance.save() result = to_dict_with_custom_fields(instance, USER_VALUES) return strip_empty_optional_fields(result)
def organisation_update(request, body, organisation_id, *args, **kwargs): """ :param request: An HttpRequest :param body: A dictionary containing the parsed and validated body :type body: dict :param organisation_id: An integer identifying an organisation a user belongs to :type organisation_id: integer """ organisation = get_object_or_404(Organisation, id=organisation_id) for attr, value in body.items(): try: setattr(organisation, attr, value) except Exception as e: LOGGER.error("Failed to set user attribute %s: %s" % (attr, e)) organisation.save() result = to_dict_with_custom_fields(organisation, ORGANISATION_VALUES) return strip_empty_optional_fields(result)
def client_list(request, offset=None, limit=None, client_ids=None, client_token_id=None, *args, **kwargs): """ :param request: An HttpRequest :param offset: (optional) An optional query parameter specifying the offset in the result set to start from. :type offset: integer :param limit: (optional) An optional query parameter to limit the number of results returned. :type limit: integer :param client_ids: (optional) An optional list of client ids :type client_ids: array :param client_token_id: (optional) An optional client id to filter on. This is not the primary key. :type client_token_id: string """ offset = int(offset if offset else settings.DEFAULT_LISTING_OFFSET) limit = check_limit(limit) clients = Client.objects.order_by("id") if client_ids: clients = clients.filter(id__in=client_ids) if client_token_id: clients = clients.filter(client_id=client_token_id) clients = clients.annotate( x_total_count=RawSQL("COUNT(*) OVER ()", []))[offset:offset + limit] return ([ strip_empty_optional_fields( to_dict_with_custom_fields(client, CLIENT_VALUES)) for client in clients ], { "X-Total-Count": clients[0].x_total_count if clients else 0 })
def user_list(request, offset=None, limit=None, birth_date=None, country=None, date_joined=None, email=None, email_verified=None, first_name=None, gender=None, is_active=None, last_login=None, last_name=None, msisdn=None, msisdn_verified=None, nickname=None, organisation_id=None, updated_at=None, username=None, q=None, tfa_enabled=None, has_organisation=None, order_by=None, user_ids=None, site_ids=None, *args, **kwargs): """ :param request: An HttpRequest :param offset: (optional) An optional query parameter specifying the offset in the result set to start from. :type offset: integer :param limit: (optional) An optional query parameter to limit the number of results returned. :type limit: integer :param birth_date: (optional) An optional birth_date range filter :type birth_date: string :param country: (optional) An optional country filter :type country: string :param date_joined: (optional) An optional date joined range filter :type date_joined: string :param email: (optional) An optional case insensitive email inner match filter :type email: string :param email_verified: (optional) An optional email verified filter :type email_verified: boolean :param first_name: (optional) An optional case insensitive first name inner match filter :type first_name: string :param gender: (optional) An optional gender filter :type gender: string :param is_active: (optional) An optional is_active filter :type is_active: boolean :param last_login: (optional) An optional last login range filter :type last_login: string :param last_name: (optional) An optional case insensitive last name inner match filter :type last_name: string :param msisdn: (optional) An optional case insensitive MSISDN inner match filter :type msisdn: string :param msisdn_verified: (optional) An optional MSISDN verified filter :type msisdn_verified: boolean :param nickname: (optional) An optional case insensitive nickname inner match filter :type nickname: string :param organisation_id: (optional) An optional filter on the organisation id :type organisation_id: integer :param updated_at: (optional) An optional updated_at range filter :type updated_at: string :param username: (optional) An optional case insensitive username inner match filter :type username: string :param q: (optional) An optional case insensitive inner match filter across all searchable text fields :type q: string :param tfa_enabled: (optional) An optional filter based on whether a user has 2FA enabled or not :type tfa_enabled: boolean :param has_organisation: (optional) An optional filter based on whether a user belongs to an organisation or not :type has_organisation: boolean :param order_by: (optional) Fields and directions to order by, e.g. "-created_at,username". Add "-" in front of a field name to indicate descending order. :type order_by: array :param user_ids: (optional) An optional list of user ids :type user_ids: array :param site_ids: (optional) An optional list of site ids :type site_ids: array """ offset = int(offset if offset else settings.DEFAULT_LISTING_OFFSET) limit = check_limit(limit) order_by = order_by or ["id"] users = get_user_model().objects.order_by(*order_by) # Bools if tfa_enabled is not None: users = users.filter(totpdevice__isnull=not tfa_enabled) if has_organisation is not None: users = users.filter(organisation__isnull=not has_organisation) if email_verified is not None: users = users.filter(email_verified=email_verified) if is_active is not None: users = users.filter(is_active=is_active) if msisdn_verified is not None: users = users.filter(msisdn_verified=msisdn_verified) # Dates if birth_date: ranges = range_filter_parser(birth_date) users = users.filter( **{"birth_date__%s" % k: v for k, v in ranges.items()}) if date_joined: ranges = range_filter_parser(date_joined) users = users.filter( **{"date_joined__date__%s" % k: v for k, v in ranges.items()}) if last_login: ranges = range_filter_parser(last_login) users = users.filter( **{"last_login__date__%s" % k: v for k, v in ranges.items()}) if updated_at: ranges = range_filter_parser(updated_at) users = users.filter( **{"updated_at__date__%s" % k: v for k, v in ranges.items()}) # Partial matches if email: users = users.filter(email__ilike=email) if first_name: users = users.filter(first_name__ilike=first_name) if username: users = users.filter(username__ilike=username) if msisdn: users = users.filter(msisdn__ilike=msisdn) if last_name: users = users.filter(last_name__ilike=last_name) if nickname: users = users.filter(nickname__ilike=nickname) if q: users = users.filter(q__ilike=q) # Other filters if country: users = users.filter(country__code=country) if user_ids: users = users.filter(id__in=user_ids) if gender: users = users.filter(gender=gender) if organisation_id: users = users.filter(organisation__id=organisation_id) if site_ids: # In order for the count to be correct, we cannot join with the UserSite table and # need to use a subquery. site_user_ids = UserSite.objects.distinct().filter( site_id__in=site_ids).values("user_id") users = users.filter(id__in=site_user_ids) # Add count users = users.annotate(x_total_count=RawSQL("COUNT(*) OVER ()", [])) # Perform the query and get the correct slice users = users[offset:offset + limit] return ([ strip_empty_optional_fields( to_dict_with_custom_fields(user, USER_VALUES)) for user in users ], { "X-Total-Count": users[0].x_total_count if users else 0 })