lemoncurry/users/models.py

235 lines
7 KiB
Python
Raw Permalink Normal View History

from computed_property import ComputedCharField
2017-10-22 18:04:59 -04:00
from django.db import models
from django.contrib.auth.models import AbstractUser, UserManager as DjangoUserManager
from django.contrib.sites.models import Site as DjangoSite
from django.utils.functional import cached_property
from hashlib import md5, sha256
from meta.models import ModelMeta
from urllib.parse import urljoin
from lemoncurry import utils
2017-10-22 18:04:59 -04:00
def avatar_path(instance, name):
return 'avatars/{id}/{name}'.format(id=instance.id, name=name)
2017-10-22 21:59:10 -04:00
class Site(models.Model):
name = models.CharField(max_length=100, unique=True)
icon = models.CharField(max_length=100)
domain = models.CharField(max_length=100, blank=True)
url_template = models.CharField(max_length=100)
def format(self, username=''):
return self.url_template.format(domain=self.domain, username=username)
@property
def url(self):
return self.format()
2017-10-22 21:59:10 -04:00
def __str__(self):
return self.name
class Meta:
ordering = ('name',)
2017-10-22 21:59:10 -04:00
class UserManager(DjangoUserManager):
def get_queryset(self):
return super(UserManager, self).get_queryset().prefetch_related('keys', 'profiles')
class User(ModelMeta, AbstractUser):
"""
A user in the system - each user will have a representative h-card
generated based on all their associated information and may author as many
h-entries (:model:`entries.Entry`) as they wish.
"""
objects = UserManager()
avatar = models.ImageField(
upload_to=avatar_path,
help_text='an avatar or photo that represents this user'
)
note = models.TextField(
blank=True,
help_text='a bio or short description provided by the user'
)
xmpp = models.EmailField(
blank=True,
help_text='an XMPP address through which the user may be reached'
)
2017-10-24 21:07:57 -04:00
# This is gonna need to change if I ever decide to add multiple-user support ;)
url = '/'
email_md5 = ComputedCharField(
compute_from='calc_email_md5', max_length=32, unique=True,
help_text="MD5 hash of the user's email, used for Libravatar"
)
email_sha256 = ComputedCharField(
compute_from='calc_email_sha256', max_length=64, unique=True,
help_text="SHA-256 hash of the user's email, used for Libravatar"
)
openid_sha256 = ComputedCharField(
compute_from='calc_openid_sha256', max_length=64, unique=True,
help_text="SHA-256 hash of the user's OpenID URL, used for Libravatar"
)
@property
def calc_email_md5(self):
return md5(self.email.lower().encode('utf-8')).hexdigest()
@property
def calc_email_sha256(self):
return sha256(self.email.lower().encode('utf-8')).hexdigest()
@property
def calc_openid_sha256(self):
return sha256(self.full_url.encode('utf-8')).hexdigest()
@property
def name(self):
return '{0} {1}'.format(self.first_name, self.last_name)
def get_absolute_url(self):
return self.absolute_url
@property
def absolute_url(self):
return self.full_url
2017-10-22 21:33:24 -04:00
@property
def full_url(self):
base = 'https://' + DjangoSite.objects.get_current().domain
return urljoin(base, self.url)
@property
def description(self):
return utils.to_plain(self.note)
@property
def avatar_url(self):
return self.avatar.url
@cached_property
def facebook_id(self):
for p in self.profiles.all():
if p.site.name == 'Facebook':
return p.username
return None
@cached_property
def twitter_username(self):
for p in self.profiles.all():
if p.site.name == 'Twitter':
return '@' + p.username
return None
@property
def json_ld(self):
base = 'https://' + DjangoSite.objects.get_current().domain
return {
'@context': 'http://schema.org',
'@type': 'Person',
'@id': self.full_url,
'url': self.full_url,
'name': self.name,
'email': self.email,
'image': urljoin(base, self.avatar.url),
'givenName': self.first_name,
'familyName': self.last_name,
'sameAs': [profile.url for profile in self.profiles.all()]
}
_metadata = {
'image': 'avatar_url',
'description': 'description',
'og_type': 'profile',
'og_profile_id': 'facebook_id',
'twitter_creator': 'twitter_username',
}
2017-10-22 21:33:24 -04:00
class ProfileManager(models.Manager):
def get_queryset(self):
return super(ProfileManager, self).get_queryset().select_related('site')
2017-10-22 21:59:10 -04:00
class Profile(models.Model):
"""
Represents a particular :model:`users.User`'s identity on a particular
:model:`users.Site` - each user may have as many profiles on as many sites
as they wish, and all profiles will become `rel="me"` links on their
representative h-card. Additionally, :model:`entries.Syndication` is
tracked by linking each syndication to a particular profile.
"""
objects = ProfileManager()
2017-10-22 21:59:10 -04:00
user = models.ForeignKey(
User,
related_name='profiles',
on_delete=models.CASCADE
)
site = models.ForeignKey(Site, on_delete=models.CASCADE)
username = models.CharField(
max_length=100,
help_text="the user's actual handle or ID on the remote site"
)
display_name = models.CharField(
max_length=100,
blank=True,
help_text="overrides the username for display - useful for sites that use ugly IDs"
)
2017-10-22 21:59:10 -04:00
def __str__(self):
if self.site.domain:
return self.name + '@' + self.site.domain
return self.name
2017-10-22 21:59:10 -04:00
@property
def name(self):
return self.display_name or self.username
@property
def url(self):
return self.site.format(username=self.username)
2017-10-22 21:59:10 -04:00
class Meta:
ordering = ('site', 'username')
2017-10-22 21:33:24 -04:00
class Key(models.Model):
"""
Represents a PGP key that belongs to a particular :model:`users.User`. Each
key will be added to the user's h-card with rel="pgpkey", a format
compatible with IndieAuth.com.
"""
2017-10-22 21:33:24 -04:00
user = models.ForeignKey(
User,
related_name='keys',
on_delete=models.CASCADE
)
fingerprint = models.CharField(max_length=40)
file = models.FileField(upload_to='keys')
2017-10-22 21:59:10 -04:00
@property
def key_id(self):
"""
Returns the key ID, defined as the last eight characters of the key's
fingerprint. Key IDs are not cryptographically secure (it's easy to
forge a key with any key ID of your choosing), but when you have
already imported a key using its full fingerprint, the key ID is a
convenient way to refer to it.
"""
return self.fingerprint[32:]
2017-10-22 21:59:10 -04:00
def __str__(self):
return self.key_id
2017-10-22 21:33:24 -04:00
def pretty_print(self):
"""
Groups the PGP fingerprint into four-character chunks for display, the
same way GnuPG does. This can make reading the fingerprint a little
friendlier.
"""
2017-10-22 21:33:24 -04:00
return " ".join(self.fingerprint[i:i+4] for i in range(0, 40, 4))