summaryrefslogtreecommitdiffstats
path: root/devel/models.py
blob: d7b6c379aad86e17791f52ea02cba4151d388247 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
# -*- coding: utf-8 -*-
import pytz

from django.urls import reverse
from django.db import models
from django.db.models.signals import pre_save, post_save
from django.contrib.auth.models import User, Group
from django_countries.fields import CountryField

from .fields import PGPKeyField
from main.utils import make_choice, set_created_field

from planet.models import Feed


class UserProfile(models.Model):
    notify = models.BooleanField(
        "Send notifications",
        default=True,
        help_text="When enabled, send user 'flag out-of-date' notifications")
    time_zone = models.CharField(
        max_length=100,
        choices=make_choice(pytz.common_timezones),
        default="UTC",
        help_text="Used for developer clock page")
    alias = models.CharField(
        max_length=50,
        help_text="Required field")
    public_email = models.CharField(
        max_length=50,
        help_text="Required field")
    other_contact = models.CharField(max_length=100, null=True, blank=True)
    pgp_key = PGPKeyField(max_length=40, null=True, blank=True,
        verbose_name="PGP key fingerprint",
        help_text="consists of 40 hex digits; use `gpg --fingerprint`")
    website = models.CharField(max_length=200, null=True, blank=True)
    website_rss = models.CharField(max_length=200, null=True, blank=True,
                                   help_text='RSS Feed of your website for planet.archlinux.org')
    yob = models.IntegerField("Year of birth", null=True, blank=True)
    country = CountryField(blank=True)
    location = models.CharField(max_length=50, null=True, blank=True)
    languages = models.CharField(max_length=50, null=True, blank=True)
    interests = models.CharField(max_length=255, null=True, blank=True)
    occupation = models.CharField(max_length=50, null=True, blank=True)
    roles = models.CharField(max_length=255, null=True, blank=True)
    favorite_distros = models.CharField(max_length=255, null=True, blank=True)
    picture = models.FileField(upload_to='devs', default='devs/silhouette.png',
        help_text="Ideally 125px by 125px")
    user = models.OneToOneField(User, related_name='userprofile', on_delete=models.CASCADE)
    allowed_repos = models.ManyToManyField('main.Repo', blank=True)
    latin_name = models.CharField(max_length=255, null=True, blank=True,
        help_text="Latin-form name; used only for non-Latin full names")
    last_modified = models.DateTimeField(editable=False)

    class Meta:
        db_table = 'user_profiles'
        get_latest_by = 'last_modified'
        verbose_name = 'additional profile data'
        verbose_name_plural = 'additional profile data'

    def get_absolute_url(self):
        user = self.user
        group = StaffGroup.objects.filter(group=user.groups.all().first()).get()
        if group:
            return '%s#%s' % (group.get_absolute_url(), user.username)
        return None


class StaffGroup(models.Model):
    name = models.CharField(max_length=100)
    slug = models.SlugField(max_length=100, unique=True)
    group = models.OneToOneField(Group, on_delete=models.CASCADE)
    sort_order = models.PositiveIntegerField()
    member_title = models.CharField(max_length=100)
    description = models.TextField(blank=True)

    class Meta:
        ordering = ('sort_order',)

    def __str__(self):
        return self.name

    def get_absolute_url(self):
        return reverse('people', args=[self.slug])


class MasterKey(models.Model):
    owner = models.ForeignKey(User, related_name='masterkey_owner',
        help_text="The developer holding this master key", on_delete=models.CASCADE)
    revoker = models.ForeignKey(User, related_name='masterkey_revoker',
        help_text="The developer holding the revocation certificate", on_delete=models.CASCADE)
    pgp_key = PGPKeyField(max_length=40, verbose_name="PGP key fingerprint",
        help_text="consists of 40 hex digits; use `gpg --fingerprint`")
    created = models.DateField()
    revoked = models.DateField(null=True, blank=True)

    class Meta:
        ordering = ('created',)
        get_latest_by = 'created'

    def __str__(self):
        return '%s, created %s' % (
                self.owner.get_full_name(), self.created)


class DeveloperKey(models.Model):
    owner = models.ForeignKey(User, related_name='all_keys', null=True,
            help_text="The developer this key belongs to", on_delete=models.CASCADE)
    key = PGPKeyField(max_length=40, verbose_name="PGP key fingerprint",
            unique=True)
    created = models.DateTimeField()
    expires = models.DateTimeField(null=True, blank=True)
    revoked = models.DateTimeField(null=True, blank=True)
    parent = models.ForeignKey('self', null=True, on_delete=models.SET_NULL)

    def __str__(self):
        return self.key


class PGPSignature(models.Model):
    signer = PGPKeyField(max_length=40, verbose_name="Signer key fingerprint",
            db_index=True)
    signee = PGPKeyField(max_length=40, verbose_name="Signee key fingerprint",
            db_index=True)
    created = models.DateField()
    expires = models.DateField(null=True, blank=True)
    revoked = models.DateField(null=True, blank=True)

    class Meta:
        ordering = ('signer', 'signee')
        get_latest_by = 'created'
        verbose_name = 'PGP signature'

    def __str__(self):
        return '%s → %s' % (self.signer, self.signee)


def create_feed_model(sender, **kwargs):
    set_created_field(sender, **kwargs)

    obj = kwargs['instance']

    if not obj.id:
        return

    dbmodel = UserProfile.objects.get(id=obj.id)

    if not obj.website_rss and dbmodel.website_rss:
        Feed.objects.filter(website_rss=dbmodel.website_rss).all().delete()
        return

    if not obj.website_rss:
        return

    if obj.website:
        website = obj.website
    else:
        from urllib.parse import urlparse
        parsed = urlparse(obj.website_rss)
        website = obj.website_rss.replace(parsed.path, '')

    # Nothing changed
    if obj.website_rss == dbmodel.website_rss:
        return

    title = obj.alias
    if obj.user.first_name and obj.user.last_name:
        title = obj.user.first_name + ' ' + obj.user.last_name

    # Remove old feeds
    Feed.objects.filter(website_rss=dbmodel.website_rss).all().delete()
    Feed.objects.create(title=title, website=website,
                        website_rss=obj.website_rss)


def delete_feed_model(sender, **kwargs):
    '''When a user is set to inactive remove his feed model'''

    obj = kwargs['instance']

    if not obj.id:
        return

    if obj.is_active:
        return

    userprofile = UserProfile.objects.filter(user=obj).first()
    if not userprofile:
        return

    Feed.objects.filter(website_rss=userprofile.website_rss).delete()


pre_save.connect(create_feed_model, sender=UserProfile,
        dispatch_uid="devel.models")

post_save.connect(delete_feed_model, sender=User,
        dispatch_uid='main.models')

# vim: set ts=4 sw=4 et: