Пример #1
0
 def __init__(self, email, password, timeout=86400):
     self.auth = Auth(email=email, password=password, timeout=timeout)
     self.credential = Credential(self.auth)
     self.group = Group(self.auth)
     self.role = Role(self.auth)
     self.stats = Stats(self.auth)
     self.subscriber = Subscriber(self.auth)
     self.user = User(self.auth)
Пример #2
0
class Client(object):

    status = ""

    def __init__(self, email, password, timeout=86400):
        self.auth = Auth(email=email, password=password, timeout=timeout)
        self.credential = Credential(self.auth)
        self.group = Group(self.auth)
        self.role = Role(self.auth)
        self.stats = Stats(self.auth)
        self.subscriber = Subscriber(self.auth)
        self.user = User(self.auth)

    def auth(self):
        return Auth(self.auth)

    def list_subscribers(self, tag_name=None, tag_value=None,
                         tag_value_match_mode="exact", status_filter=None,
                         speed_class_filter=None, limit=None,
                         last_evaluated_key=None):
        """List subscribers."""
        status, body = self.subscriber.list_subscribers(
            tag_name=tag_name, tag_value=tag_value,
            tag_value_match_mode=tag_value_match_mode,
            status_filter=status_filter,
            speed_class_filter=speed_class_filter, limit=limit,
            last_evaluated_key=last_evaluated_key)
        return body

    def register_subscriber(self, imsi, registration_secret, group_id=None,
                            tags={}):
        """Register subscriber."""
        status, body = self.subscriber.register(imsi, registration_secret,
                                                group_id, tags)
        return body

    def activate_subscriber(self, imsi):
        """Activate subscriber."""
        status, body = self.subscriber.activate_subscriber(imsi)
        return body

    def deactivate_subscriber(self, imsi):
        """Deactivate subscriber."""
        status, body = self.subscriber.deactivate_subscriber(imsi)
        return body

    def terminate_subscriber(self, imsi):
        """Terminate subscriber"""
        status, body = self.subscriber.terminate_subscriber(imsi)
        return body

    def enable_termination(self, imsi):
        """Enable termination of subscriber."""
        status, body = self.subscriber.enable_termination(imsi)
        return body

    def disable_termination(self, imsi):
        """Disable termination of subscriber."""
        status, body = self.subscriber.disable_termination(imsi)
        return body

    def update_subscriber_tags(self, imsi, tags):
        """Bulk insert or update subscriber tags."""
        status, body = self.subscriber.update_subscriber_tags(imsi, tags)
        return body

    def delete_subscriber_tag(self, imsi, tag_name):
        """Delete subscriber tag."""
        status, body = self.subscriber.delete_subscriber_tag(imsi, tag_name)
        return body

    def update_subscriber_speed_class(self, imsi, speed_class):
        """Update subscriber speed class."""
        status, body = self.subscriber.update_subscriber_speed_class(
            imsi, speed_class)
        return body

    def set_expiry_time(self, imsi, expiry_time):
        """Update expiry time of subscriber."""
        status, body = self.subscriber.set_expiry_time(imsi, expiry_time)
        return body

    def unset_expiry_time(self, imsi):
        """Delete expiry time of subscriber."""
        status, body = self.subscriber.unset_expiry_time(imsi)
        return body

    def set_group(self, imsi, group_id):
        """Set group to subscriber."""
        status, body = self.subscriber.set_group(imsi, group_id)
        return body

    def unset_group(self, imsi):
        """Unset group to subscriber."""
        status, body = self.subscriber.unset_group(imsi)
        return body

    def list_groups(self, group_id=None, tag_name=None, tag_value=None,
                    limit=None, tag_value_match_mode=None,
                    last_evaluated_key=None):
        """List groups."""

        status, body = self.group.list_groups(
            group_id=group_id, tag_name=tag_name,
            tag_value=tag_value, limit=limit,
            tag_value_match_mode=tag_value_match_mode,
            last_evaluated_key=last_evaluated_key)
        return body

    def create_group(self, tags=None):
        """Create group."""
        status, body = self.group.create_group(tags)
        return body

    def delete_group(self, group_id):
        """Delete group."""
        status, body = self.group.delete_group(group_id)
        return body

    def list_subscribers_in_group(self, group_id, limit=None,
                                  last_evaluated_key=None):
        """List subscribers in a group."""
        status, body = self.group.list_subscribers_in_group(
            group_id=group_id, limit=limit,
            last_evaluated_key=last_evaluated_key)
        return body

    def update_group_configuration(self, group_id, namespace, params):
        """Update group configuration parameters."""
        status, body = self.group.update_group_configuration(
            group_id=group_id, namespace=namespace, params=params)
        return body

    def delete_group_configuration(self, group_id, namespace, name):
        """Delete group configuration parameters."""
        status, body = self.group.delete_group_configuration(
            group_id=group_id, namespace=namespace, name=name)
        return body

    def update_group_tags(self, group_id, tags={}):
        """Update group tags."""
        status, body = self.group.update_group_tags(group_id, tags)
        return body

    def delete_group_tags(self, group_id, name):
        """Delete group tag."""
        status, body = self.group.delete_group_tags(group_id, name)
        return body

    def list_event_handlers(self, handler_id=None, target=None, imsi=None):
        """List event handlers."""
        status, body = self.event_handler.list_event_handlers(
            handler_id=handler_id, target=target, imsi=imsi)
        return body

    def create_event_handler(self, request):
        """Create event handler."""
        status, body = self.event_handler.create_event_handler(request)
        return body

    def get_event_handler(self, handler_id):
        """Get event handler."""
        status, body = self.event_handler.get_event_handler(handler_id)
        return body

    def delete_event_handler(self, handler_id):
        """Delete event handler."""
        status, body = self.event_handler.delete_event_handler(handler_id)
        return body

    def update_event_handler(self, handler_id, req):
        """Update event handler."""
        status, body = self.event_handler.update_event_handler(handler_id, req)
        return body

    def get_air_usage(self, imsi,
                      from_unixtime=int(time.time() - 24 * 60 * 60),
                      to_unixtime=int(time.time()), period='minutes'):
        """Get air usage report of subscriber."""
        status, body = self.stats.get_air_usage(
            imsi, from_unixtime=from_unixtime, to_unixtime=to_unixtime,
            period=period)
        return body

    def get_beam_usage(self, imsi,
                       from_unixtime=int(time.time() - 24 * 60 * 60),
                       to_unixtime=int(time.time()), period='minutes'):
        """Get beam usage report of subscriber."""
        status, body = self.stats.get_beam_usage(
            imsi, from_unixtime=from_unixtime, to_unixtime=to_unixtime,
            period=period)
        return body

    def export_air_usage(self, operator_id=None,
                         from_unixtime=int(time.time() - 24 * 60 * 60 * 30),
                         to_unixtime=int(time.time()), period="day"):
        """Export air usage report of all subscribers."""
        if operator_id is None:
            operator_id = self.auth.operator_id
        status, body = self.stats.export_air_usage(operator_id, from_unixtime,
                                                   to_unixtime, period)
        return body

    def export_beam_usage(self, operator_id=None,
                          from_unixtime=int(time.time() - 24 * 60 * 60 * 30),
                          to_unixtime=int(time.time()), period="day"):
        """Export beam usage report of all subscribers."""
        if operator_id is None:
            operator_id = self.auth.operator_id
        status, body = self.stats.export_beam_usage(operator_id, from_unixtime,
                                                    to_unixtime, period)
        return body

    def list_credentials(self):
        """List credentials."""
        status, body = self.credential.list_credentials()
        return body

    def create_credential(self, credentials_id, credentials):
        """Create credential."""
        status, body = self.credential.create_credential(credentials_id,
                                                         credentials)
        return body

    def delete_credential(self, credentials_id):
        """Delete credential."""
        status, body = self.credential.delete_credential(credentials_id)
        return body

    def list_users(self):
        """List users."""
        status, body = self.user.list_users()
        return body

    def delete_user(self, username):
        """Delete user."""
        status, body = self.user.delete_user(username)
        return body

    def get_user(self, username):
        """Get user."""
        status, body = self.user.get_user(username)
        return body

    def create_user(self, username, description=""):
        """Create user."""
        status, body = self.user.create_user(username, description)
        return body

    def update_user(self, username, description=""):
        """Update user."""
        status, body = self.user.update_user(username, description)
        return body

    def list_user_auth_keys(self, username):
        """List user auth keys."""
        status, body = self.user.list_user_auth_keys(username)
        return body

    def generate_user_auth_key(self, username):
        """Generate auth key."""
        status, body = self.user.generate_user_auth_key(username)
        return body

    def delete_user_auth_key(self, username, auth_key_id):
        """Delete user auth key."""
        status, body = self.user.delete_user_auth_key(username, auth_key_id)
        return body

    def get_user_auth_key(self, username, auth_key_id):
        """Get auth key."""
        status, body = self.user.get_user_auth_key(username, auth_key_id)
        return body

    def delete_user_password(self, username):
        """Delete password."""
        status, body = self.user.delete_user_password(username)
        return body

    def has_user_password(self, username):
        """Has user password."""
        status, body = self.user.has_user_password(username)
        return body

    def create_user_password(self, username, password):
        """Create password."""
        status, body = self.user.create_user_password(username, password)
        return body

    def get_user_permission(self, username):
        """Get user permission."""
        status, body = self.user.get_user_permission(username)
        return body

    def update_user_permission(self, username, permission="", description=""):
        """Update permission to user."""
        status, body = self.user.update_user_permission(username, permission,
                                                        description)
        return body

    def list_roles(self):
        """List roles."""
        status, body = self.role.list_roles()
        return body

    def delete_role(self, role_id):
        """Delete role."""
        status, body = self.role.delete_role(role_id)
        return body

    def get_role(self, role_id):
        """Get role."""
        status, body = self.role.get_role(role_id)
        return body

    def create_role(self, role_id, permission, description=""):
        """Create role."""
        status, body = self.role.create_role(role_id, permission, description)
        return body

    def update_role(self, role_id, permission, description=""):
        """Update role."""
        status, body = self.role.update_role(role_id, permission, description)
        return body

    def list_role_attached_users(self, role_id):
        """List role attached users."""
        status, body = self.role.list_role_attached_users(role_id)
        return body

    def list_user_roles(self, username):
        """List user roles."""
        status, body = self.role.list_user_roles(username)
        return body

    def attach_role_to_user(self, username, role_id):
        """Attach role to user."""
        status, body = self.role.attach_role_to_user(username, role_id)
        return body

    def detach_role_from_user(self, username, role_id):
        """Detach role from user."""
        status, body = self.role.detach_role_from_user(username, role_id)
        return body