# evennia.accounts.models

Account

The account class is an extension of the default Django user class, and is customized for the needs of Evennia.

We use the Account to store a more mud-friendly style of permission system as well as to allow the admin more flexibility by storing attributes on the Account. Within the game we should normally use the Account manager’s methods to create users so that permissions are set correctly.

To make the Account model more flexible for your own game, it can also persistently store attributes of its own. This is ideal for extra account info and OOC account configuration variables etc.

class `evennia.accounts.models.``AccountDB`(*args, **kwargs)

  Bases: `evennia.typeclasses.models.TypedObject`, `django.contrib.auth.models.AbstractUser`

  This is a special model using Django’s ‘profile’ functionality and extends the default Django User model. It is defined as such by use of the variable AUTH_PROFILE_MODULE in the settings. One accesses the fields/methods. We try use this model as much as possible rather than User, since we can customize this to our liking.

  The TypedObject supplies the following (inherited) properties:

  > - key - main name

  > - typeclass_path - the path to the decorating typeclass

  > - typeclass - auto-linked typeclass

  > - date_created - time stamp of object creation

  > - permissions - perm strings

  > - dbref - #id of object

  > - db - persistent attribute storage

  > - ndb - non-persistent attribute storage

  The AccountDB adds the following properties:

  > - is_connected - If any Session is currently connected to this Account

  > - name - alias for user.username

  > - sessions - sessions connected to this account

  > - is_superuser - bool if this account is a superuser

  > - is_bot - bool if this account is a bot and not a real account

  `db_is_connected`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `db_cmdset_storage`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `db_is_bot`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `objects` = <evennia.accounts.manager.AccountDBManager object>
  property `cmdset_storage`

    Getter. Allows for value = self.name. Returns a list of cmdset_storage.

  property `name`
  property `key`
  property `uid`

    Getter. Retrieves the user id

  exception `DoesNotExist`

    Bases: `django.core.exceptions.ObjectDoesNotExist`

  exception `MultipleObjectsReturned`

    Bases: `django.core.exceptions.MultipleObjectsReturned`

  `account_subscription_set`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `date_joined`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `db_attributes`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `db_date_created`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `db_key`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `db_lock_storage`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `db_tags`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `db_typeclass_path`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `email`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `first_name`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `get_next_by_date_joined`(*, field=<django.db.models.fields.DateTimeField: date_joined>, is_next=True, **kwargs)
  `get_next_by_db_date_created`(*, field=<django.db.models.fields.DateTimeField: db_date_created>, is_next=True, **kwargs)
  `get_previous_by_date_joined`(*, field=<django.db.models.fields.DateTimeField: date_joined>, is_next=False, **kwargs)
  `get_previous_by_db_date_created`(*, field=<django.db.models.fields.DateTimeField: db_date_created>, is_next=False, **kwargs)
  `groups`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `hide_from_accounts_set`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `id`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `is_active`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  property `is_bot`

    A wrapper for getting database field db_is_bot.

  property `is_connected`

    A wrapper for getting database field db_is_connected.

  `is_staff`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `is_superuser`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `last_login`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `last_name`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `logentry_set`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    **Parent.children** is a **ReverseManyToOneDescriptor** instance.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `objectdb_set`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    **Parent.children** is a **ReverseManyToOneDescriptor** instance.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `password`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.

  `path` = 'evennia.accounts.models.AccountDB'
  `receiver_account_set`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `scriptdb_set`

    Accessor to the related objects manager on the reverse side of a many-to-one relation.

    In the example:

        class Child(Model):
            parent = ForeignKey(Parent, related_name='children')

    **Parent.children** is a **ReverseManyToOneDescriptor** instance.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `sender_account_set`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `typename` = 'SharedMemoryModelBase'
  `user_permissions`

    Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

    In the example:

        class Pizza(Model):
            toppings = ManyToManyField(Topping, related_name='pizzas')

    **Pizza.toppings** and **Topping.pizzas** are **ManyToManyDescriptor** instances.

    Most of the implementation is delegated to a dynamically defined manager class built by **create_forward_many_to_many_manager()** defined below.

  `username`

    A wrapper for a deferred-loading field. When the value is read from this object the first time, the query is executed.