class Car(TimeStampedModel):
id = models.UUIDField(verbose_name='ID', default=uuid.uuid4, editable=False, primary_key=True)
active = models.BooleanField()
year = models.SmallIntegerField(verbose_name='Year',
validators=[MinValueValidator(1900)],
blank=True, null=True)
mileage = models.PositiveIntegerField()
price = models.PositiveIntegerField()
submodel = models.ForeignKey(Submodel, on_delete=models.PROTECT)
body_type = models.CharField(max_length=300, blank=True)
transmission = models.CharField(max_length=300, blank=True)
fuel_type = models.CharField(max_length=300, blank=True)
exterior_color = models.CharField(max_length=300, blank=True)
created_at = AutoCreatedField()
updated_at = AutoLastModifiedField()
class Meta:
verbose_name = 'car'
verbose_name_plural = 'cars'
@property
def model(self):
return self.submodel.model
@property
def make(self):
return self.submodel.model.make
class Model(models.Model):
id = models.CharField(max_length=300, primary_key=True)
name = models.CharField(max_length=300, blank=True)
active = models.BooleanField()
make = models.ForeignKey(Make, on_delete=models.PROTECT, related_name='models')
created_at = AutoCreatedField()
updated_at = AutoLastModifiedField()
class PersonFilmWork(models.Model):
id = models.UUIDField(primary_key=True,
default=uuid4,
editable=False,
db_index=True)
film_work = models.ForeignKey(
FilmWork,
verbose_name=_('кинопроизведение'),
related_name='person_film_work',
on_delete=models.CASCADE,
)
person = models.ForeignKey(
Person,
verbose_name=_('персона'),
related_name='person_film_work',
on_delete=models.CASCADE,
)
role = models.CharField(_('роль'),
choices=RoleType.choices,
max_length=255)
created_at = AutoCreatedField(_('добавлено'))
class Meta:
managed = False
db_table = 'content"."person_film_work'
verbose_name = _('связь фильмов и персоналий')
verbose_name_plural = _('связи фильмов и персоналий')
unique_together = (('film_work_id', 'person_id', 'role'), )
def __str__(self):
return f'{self.person.full_name} as {self.role} @ "{self.film_work.title}"'
class Link(models.Model):
id = models.UUIDField(primary_key=True, default=uuid4, editable=False)
created = AutoCreatedField()
modified = AutoLastModifiedField()
title = models.CharField(max_length=128)
url = models.URLField()
imageUrl = models.URLField(default="")
description = models.TextField(default="")
order = models.IntegerField(default=1)
objects = LinkManager()
owner = models.ForeignKey("account.User",
on_delete=models.CASCADE,
related_name="links")
list = models.ForeignKey(List,
on_delete=models.CASCADE,
related_name="links")
class Meta:
ordering = ("order", )
index_together = ("list", "order")
def __str__(self):
return f"<Link - {self.title}>"
class Package(models.Model):
created = AutoCreatedField(db_index=True)
modified = AutoLastModifiedField()
name = models.SlugField(max_length=200, unique=True)
#: Indicate if this package is local (a private package)
is_local = models.BooleanField(default=False)
#: Timestamp when we last retrieved the metadata
update_timestamp = models.DateTimeField(null=True)
owners = models.ManyToManyField(User)
class Meta:
ordering = ['name']
def __unicode__(self):
return self.name
@models.permalink
def get_absolute_url(self):
return ('packages:detail', None, {'name': self.name})
def get_all_releases(self):
result = {}
for release in self.releases.all():
files = dict((r.filename, r) for r in release.files.all())
result[release.version] = (release, files)
return result
@property
def last_release(self):
return self.releases.order_by('-created')[0]
class FilmWork(models.Model):
id = models.UUIDField(primary_key=True,
default=uuid4,
editable=False,
db_index=True)
title = models.CharField(_('название'), max_length=255)
description = models.TextField(_('описание'), blank=True)
creation_date = models.DateField(_('дата создания фильма'),
blank=True,
null=True)
certificate = models.TextField(_('сертификат'), blank=True, null=True)
file_path = models.FileField(_('файл'),
upload_to='film_works/',
blank=True)
rating = models.FloatField(_('рейтинг'),
validators=[MinValueValidator(0)],
blank=True,
null=True)
type = models.CharField(_('тип'),
choices=FilmWorkType.choices,
max_length=255)
created_at = AutoCreatedField(_('добавлено'))
updated_at = AutoLastModifiedField(_('обновлено'))
class Meta:
managed = False
db_table = 'content"."film_work'
# db_tablespace = 'content'
verbose_name = _('кинопроизведение')
verbose_name_plural = _('кинопроизведения')
def __str__(self):
return self.title
class Robot(models.Model):
name = models.CharField("名字", max_length=20)
pair = models.CharField("交易对", max_length=15)
enable = models.BooleanField("启用", default=True)
start_time = models.DateTimeField("启动时间", null=True)
ping_time = models.DateTimeField("心跳时间", null=True)
created_at = AutoCreatedField("创建于")
modified_at = AutoLastModifiedField("修改于")
credential = models.ForeignKey(
"credentials.Credential",
verbose_name="交易所凭据",
blank=True,
null=True,
on_delete=models.SET_NULL,
related_name="robots",
)
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
verbose_name="用户",
on_delete=models.CASCADE,
related_name="robots",
)
class Meta:
verbose_name = "机器人"
verbose_name_plural = "机器人"
class AccessKey(models.Model):
created = AutoCreatedField()
user = models.ForeignKey(
settings.AUTH_USER_MODEL, related_name='access_keys', on_delete=models.CASCADE)
access_key = models.UUIDField(
verbose_name='Access key', help_text='The access key',
default=uuid.uuid4, db_index=True)
secret_key = models.UUIDField(
verbose_name='Secret key', help_text='The secret key',
default=uuid.uuid4, db_index=True)
comment = models.CharField(
max_length=255, blank=True, null=True, default='',
help_text=_(
"A comment about this credential, e.g. where it's being used"))
last_usage = models.DateTimeField(null=True, blank=True)
objects = AccessKeyQuerySet.as_manager()
class Meta:
ordering = ['-created']
@property
def allow_upload(self):
return True
class TimeStampedModel(models.Model):
"""
An abstract base class model that provides self-updating
``created`` and ``modified`` fields.
"""
created = AutoCreatedField(_('created'))
modified = AutoLastModifiedField(_('modified'))
def save(self, *args, **kwargs):
"""
Overriding the save method in order to make sure that
modified field is updated even if it is not given as
a parameter to the update field argument.
"""
update_fields = kwargs.get('update_fields', None)
if update_fields is not None:
update_fields = set(update_fields)
if update_fields:
kwargs['update_fields'] = update_fields.union({'modified'})
super().save(*args, **kwargs)
class Meta:
abstract = True
class Tag(models.Model):
name = models.CharField(_("Name"), max_length=255, unique=True)
created = AutoCreatedField(_('Created'))
uuid = models.UUIDField(unique=True, default=uuid4, editable=False)
objects = TagQuerySet.as_manager()
def __str__(self):
return "#%s" % self.name
def get_absolute_url(self):
slugified_name = slugify(self.name)
if not slugified_name:
return reverse('streams:tag-by-uuid', kwargs={"uuid": str(self.uuid)})
return reverse('streams:tag', kwargs={"name": slugified_name})
def save(self, *args, **kwargs):
"""Ensure name is lower case and stripped.
Note this could lead to unique constraints when saving - make sure to also lower case and trim
the name when fetching tags, or use the given manager for that.
"""
self.name = self.name.strip().lower()
super().save()
@cached_property
def channel_group_name(self):
"""Make a safe Channel group name.
ASCII or hyphens or periods only.
"""
# TODO use just id
return ("%s_%s" % (self.id, slugify(self.name)))[:80]
class Credential(models.Model):
"""Credentials are repository bound"""
created = AutoCreatedField()
repository = models.ForeignKey('packages.Repository', related_name='credentials', on_delete=models.CASCADE)
access_key = models.UUIDField(
verbose_name='Access key',
help_text='The access key',
default=uuid.uuid4, db_index=True)
secret_key = models.UUIDField(
verbose_name='Secret key',
help_text='The secret key', default=uuid.uuid4, db_index=True)
comment = models.CharField(
max_length=255, blank=True, null=True, default='',
help_text="A comment about this credential, e.g. where it's being used")
allow_upload = models.BooleanField(
default=True,
help_text=_("Indicate if these credentials allow uploading new files"))
deactivated = models.DateTimeField(blank=True, null=True)
objects = CredentialQuerySet.as_manager()
def __str__(self):
return self.access_key.hex
class Meta:
ordering = ['-created']
class AccessKey(models.Model):
created = AutoCreatedField()
user = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name='access_keys')
access_key = UUIDField(verbose_name='Access key',
help_text='The access key',
auto=True,
db_index=True)
secret_key = UUIDField(verbose_name='Secret key',
help_text='The secret key',
auto=True,
db_index=True)
comment = models.CharField(
max_length=255,
blank=True,
null=True,
default='',
help_text=_(
"A comment about this credential, e.g. where it's being used"))
last_usage = models.DateTimeField(null=True, blank=True)
class Meta:
ordering = ['-created']
class Tag(models.Model):
name = models.CharField(_("Name"), max_length=255, unique=True)
created = AutoCreatedField(_('Created'))
objects = TagQuerySet.as_manager()
def __str__(self):
return "#%s" % self.name
def save(self, *args, **kwargs):
"""Ensure name is lower case and stripped.
Note this could lead to unique constraints when saving - make sure to also lower case and trim
the name when fetching tags, or use the given manager for that.
"""
self.name = self.name.strip().lower()
super().save()
@cached_property
def channel_group_name(self):
"""Make a safe Channel group name.
ASCII or hyphens or periods only.
Prefix with ID as we have to slugify the name and cut long guids due to asgi library group name restriction.
"""
return ("%s_%s" % (self.id, slugify(self.name)))[:80]
class Partner(models.Model):
BUSINESS_SECTOR = Choices(
(1, 'aneka_industri', 'Aneka Industri'),
(2, 'barang_konsumsi', 'Barang Konsumsi'),
(3, 'industri_dasar_dan_kimia', 'Industri Dasar dan Kimia'),
(4, 'infrastruktur', 'Infrastruktur'),
(5, 'jasa', 'Jasa'),
(6, 'keuangan', 'Keuangan'),
(7, 'perdagangan', 'Perdagangan'),
(8, 'pertambangan', 'Pertambangan'),
(9, 'pertanian', 'Pertanian'),
(10, 'properti', 'Properti'),
(11, 'transportasi', 'Transportasi'),
)
name = models.CharField(max_length=64, unique=True, db_index=True)
director = models.CharField(max_length=64, blank=True)
person_in_charge = models.CharField(max_length=64, blank=True)
business_sector = models.PositiveSmallIntegerField(choices=BUSINESS_SECTOR,
blank=True,
null=True)
address = models.CharField(max_length=256)
npwp = models.CharField(max_length=32, blank=True)
siup = models.CharField(max_length=32, blank=True)
ptkp = models.CharField(max_length=32, blank=True)
telephone = models.CharField(max_length=32, blank=True)
fax = models.CharField(max_length=32, blank=True)
is_active = models.BooleanField('active', default=True)
created = AutoCreatedField()
def __str__(self):
return self.name
class Addendum(models.Model):
document = models.ForeignKey('documents.Document',
related_name="addendums",
on_delete=models.CASCADE)
number = models.CharField(max_length=64, db_index=True)
subject = models.CharField(max_length=256)
signature_date = models.DateField(blank=True, null=True)
effective_date = models.DateField(blank=True, null=True)
expired_date = models.DateField(blank=True, null=True)
amount = models.FloatField(validators=[MinValueValidator(0)],
blank=True,
null=True)
description = models.TextField(blank=True)
job_specification = models.CharField(max_length=256, blank=True)
retention_period = models.PositiveSmallIntegerField(blank=True, null=True)
is_active = models.BooleanField('active', default=True)
created = AutoCreatedField()
class Meta:
unique_together = ('document', 'number')
def __str__(self):
return f"Number ({self.number}) : {self.subject}"
class BasePermission(models.Model):
class Meta:
abstract = True
user = models.ForeignKey(on_delete=models.CASCADE,
to=settings.AUTH_USER_MODEL,
db_index=True)
created_by = models.ForeignKey(on_delete=models.CASCADE,
to=settings.AUTH_USER_MODEL,
null=True,
blank=True,
related_name='+')
created = AutoCreatedField()
expiration_time = models.DateTimeField(null=True, blank=True)
is_active = models.NullBooleanField(default=True, db_index=True)
@classmethod
def get_url_name(cls):
raise NotImplementedError
@classmethod
def get_expired(cls):
return cls.objects.filter(expiration_time__lt=timezone.now(),
is_active=True)
@classmethod
@lru_cache(maxsize=1)
def get_all_models(cls):
return [model for model in apps.get_models() if issubclass(model, cls)]
def revoke(self):
raise NotImplementedError
class GenreFilmWork(models.Model):
id = models.UUIDField(primary_key=True,
default=uuid4,
editable=False,
db_index=True)
film_work = models.ForeignKey(
FilmWork,
verbose_name=_('кинопроизведение'),
related_name='genre_film_work',
on_delete=models.CASCADE,
)
genre = models.ForeignKey(
Genre,
verbose_name=_('жанр'),
related_name='genre_film_work',
on_delete=models.CASCADE,
)
created_at = AutoCreatedField(_('добавлено'))
class Meta:
managed = False
db_table = 'content"."genre_film_work'
verbose_name = _('связь фильмов и жанров')
verbose_name_plural = _('связи фильмов и жанров')
unique_together = (('film_work_id', 'genre_id'), )
def __str__(self):
return f'[{self.genre.name}] {self.film_work.title}'
class Location(models.Model):
code = models.CharField(max_length=16, unique=True, db_index=True)
name = models.CharField(max_length=255, db_index=True)
is_active = models.BooleanField(default=True)
created = AutoCreatedField()
def __str__(self):
return self.name
class VoiceMemo(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
created = AutoCreatedField()
sample = models.ForeignKey('Sample', null=True)
file_path = models.CharField(max_length=1024)
class Meta:
db_table = 'voice_memo'
class Event(UuidMixin):
created = AutoCreatedField()
event_type = models.CharField(max_length=100, db_index=True)
message = models.TextField()
context = BetterJSONField(blank=True)
class Meta:
ordering = ('-created', )
class Creatable(models.Model):
"""
"""
created = AutoCreatedField(_("created"))
class Meta:
abstract = True
class SSHKey(models.Model):
"""
SSH Key model.
"""
name = models.CharField(
_('SSH Key Name'),
unique=True,
null=False,
max_length=32,
blank=False,
validators=[
MinLengthValidator(3),
MaxLengthValidator(32),
RegexValidator(regex='^[0-9A-Za-z\s_.-]+$',
message=_('Only A-Za-z0-9\s_-. are allowed!'))
])
sshkey = models.TextField(_('SSH Key'),
null=False,
validators=[validate_sshkey])
created = AutoCreatedField(_('created'))
updated = AutoLastModifiedField(_('updated'))
class Meta:
ordering = ['name']
def clean(self):
self.name = self.name.strip()
if self.sshkey:
self.sshkey = self.sshkey.strip().rstrip()
def ssh_key_entry(self):
return self.sshkey + " " + self.name
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse('sshkey_detail', kwargs={'pk': self.pk})
def sshkey_short(self):
return self.sshkey[0:30]
def all_as_array():
all = []
for key in SSHKey.objects.all():
all.append(key.name)
return all
def filename2name(filename):
"""
This method is used for import of SSH Keys from the Filesystem.
It will return a useful clear name to insert it into DB from
the filename of the Key.
"""
filename = filename.strip()
filename = re.sub(r'\.pub$', '', filename)
name = re.sub(r'(-|_|\.)', ' ', filename)
return name.title()
class TimeStampedModel(models.Model):
"""
self-updating created and modified fields
"""
created = AutoCreatedField(_('created'), editable=False)
modified = AutoLastModifiedField(_('modified'), editable=False)
class Meta:
abstract = True
class TimeStampedMixin(models.Model):
"""
Add timestamp control to a model.
"""
created_at = AutoCreatedField(_('criado em'))
updated_at = AutoLastModifiedField(_('modificado em'))
class Meta:
abstract = True
class PyPIIndexPage(models.Model):
created = AutoCreatedField("created", db_index=True)
modified = AutoLastModifiedField("modified")
content = models.TextField()
def __unicode__(self):
return "PyPI Index Page: %s" % self.created.isoformat()
class ReleaseFile(models.Model):
TYPES = Choices(
('sdist', 'Source'),
('bdist_egg', 'Egg'),
('bdist_msi', 'MSI'),
('bdist_dmg', 'DMG'),
('bdist_rpm', 'RPM'),
('bdist_dumb', 'bdist_dumb'),
('bdist_wininst', 'bdist_wininst'),
('bdist_wheel', 'bdist_wheel'),
)
created = AutoCreatedField()
modified = AutoLastModifiedField()
release = models.ForeignKey(Release, related_name="files")
size = models.IntegerField(null=True)
filetype = models.CharField(max_length=25, choices=TYPES)
distribution = models.FileField(upload_to=release_file_upload_to,
storage=DistributionStorage(),
max_length=512)
filename = models.CharField(max_length=200, blank=True, null=True)
md5_digest = models.CharField(max_length=512)
python_version = models.CharField(max_length=25)
url = models.CharField(max_length=1024, blank=True)
user = models.ForeignKey(User, null=True)
class Meta:
unique_together = ('release', 'filetype', 'python_version', 'filename')
def __unicode__(self):
return self.filename
def get_absolute_url(self):
url = reverse('packages:download',
kwargs={
'name': self.release.package.name,
'pk': self.pk,
'filename': self.filename
})
return '%s#md5=%s' % (url, self.md5_digest)
def save_filecontent(self, filename, fh):
tmp_file = NamedTemporaryFile()
copyfileobj(fh, tmp_file)
self.distribution.save(filename, File(tmp_file))
class Job(models.Model):
status = models.CharField(max_length=50,
choices=JobStatus.CHOICES,
default=JobStatus.PENDING)
message = models.CharField(max_length=255, blank=True, null=True)
created_at = AutoCreatedField(_("created"), db_index=True)
updated_at = AutoLastModifiedField(_("modified"), db_index=True)
class Meta:
abstract = True
class TimeStampedModel(models.Model):
"""
An abstract base class model that provides self-updating
``created`` and ``modified`` fields.
"""
created = AutoCreatedField(_('created'), editable=False)
modified = AutoLastModifiedField(_('modified'), editable=False)
class Meta:
abstract = True
class Timestampable(models.Model):
"""
An abstract base class model that provides self-updating
``created`` and ``modified`` fields.
"""
created_at = AutoCreatedField(_('creation time'))
updated_at = AutoLastModifiedField(_('last modification time'))
class Meta:
abstract = True
class AddendumFile(models.Model):
addendum = models.ForeignKey('addendums.Addendum',
related_name="files",
on_delete=models.CASCADE)
file = models.FileField(upload_to=FilenameGenerator('addendum_file'))
is_active = models.BooleanField('active', default=True)
created = AutoCreatedField()
def __str__(self):
return str(self.file.url)
