class Resource(Model):
id = UUIDField(primary_key=True, blank=True)
description = CharField(max_length=64)
modified_by = ForeignKey(
'auth.User',
name='modified_by',
editable=False,
related_name='+',
on_delete=SET_NULL,
null=True,
blank=True,
)
hidden = BooleanField(
name='hidden',
default=False,
)
deleted = BooleanField(
name='deleted',
default=False,
)
history = HistoricalRecords(history_id_field=UUIDField(default=uuid4), )
@property
def _history_user(self):
return self.modified_by
@_history_user.setter
def _history_user(self, value):
self.modified_by = value
def save(self,
force_insert=False,
force_update=False,
using=None,
update_fields=None):
if not self.id:
self.id = uuid4()
self.changeReason = 'create'
else:
self.changeReason = 'update'
current_user = get_current_user()
if current_user:
self.modified_by = current_user
super(Resource, self).save(force_insert, force_update, using,
update_fields)
def delete(self, using=None, keep_parents=False):
self.deleted = True
self.hidden = True
self.changeReason = 'delete'
self.save()
class Event(Model):
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
secret_id = UUIDField(default=uuid.uuid4, editable=False)
title = CharField(max_length=255)
description = TextField()
host = CharField(max_length=255)
image = ImageField(upload_to='images/events/', null=True, blank=True)
start_time = DateTimeField(null=True)
end_time = DateTimeField(null=True)
location = CharField(max_length=500)
address = CharField(max_length=500, null=True, blank=True)
CATEGORY_CHOICES = (('sports', 'Sports'), ('music', 'Music'), ('academic',
'Academic'),
('party', 'Party'), ('business', 'Business'),
('ceremony', 'Ceremony'), ('workshop', 'Workshop'),
('clubs', 'Clubs'), ('other', 'Other'))
category = CharField(max_length=20, choices=CATEGORY_CHOICES)
event_type = CharField(max_length=30, default=None, null=True, blank=True)
event_url = TextField(null=True, blank=True)
ticket_url = TextField(null=True, blank=True)
is_submission = BooleanField(default=False)
is_submission_email = BooleanField(default=False)
is_published = BooleanField(default=False)
is_published_email = BooleanField(default=False)
submitter_email = EmailField(null=True)
submitter_phone = PhoneNumberField(null=True, blank=True)
objects = EventManager()
def save_image_from_url(self, url):
"""Store image locally if an external URL is passed"""
result = requests.get(url)
filename = os.path.basename(url).split('?')[0]
# Use tempfile.TemporaryFile for App Engine
temp = tempfile.TemporaryFile()
temp.write(result.content)
temp.flush()
self.image.save(filename, File(temp))
self.save()
def get_absolute_image_url(self):
"""
Returns image URL.
"""
if self.image:
return settings.MEDIA_URL + str(self.image)
class Message(Model):
id = UUIDField(primary_key=True, default=uuid4, editable=False)
creation_datetime = DateTimeField(now, auto_now_add=True, editable=False)
channel = ForeignKey(Channel, on_delete=PROTECT)
body = TextField()
source = ForeignKey(User, on_delete=PROTECT)
request_id = UUIDField(null=True, editable=False, unique=True)
def __str__(self):
s = "Message id: {id} creation_datetime time: {ct}".format(
id=str(self.id), ct=self.creation_datetime)
return s
def annotate_tree(self):
"""
Annotate the number of parent and child prefixes for each Prefix.
The UUID being used is fake for purposes of satisfying the COALESCE condition.
"""
# The COALESCE needs a valid, non-zero, non-null UUID value to do the comparison.
# The value itself has no meaning, so we just generate a random UUID for the query.
FAKE_UUID = uuid.uuid4()
from nautobot.ipam.models import Prefix
return self.annotate(
parents=Subquery(
Prefix.objects.annotate(maybe_vrf=ExpressionWrapper(
Coalesce(F("vrf_id"), FAKE_UUID),
output_field=UUIDField(),
)).filter(
Q(prefix_length__lt=OuterRef("prefix_length"))
& Q(network__lte=OuterRef("network"))
& Q(broadcast__gte=OuterRef("broadcast"))
& Q(maybe_vrf=ExpressionWrapper(
Coalesce(OuterRef("vrf_id"), FAKE_UUID),
output_field=UUIDField(),
))).order_by().
annotate(
fake_group_by=Value(1)
) # This is an ORM hack to remove the unwanted GROUP BY clause
.values("fake_group_by").annotate(
count=Count("*")).values("count")[:1],
output_field=IntegerField(),
),
children=Subquery(
Prefix.objects.annotate(maybe_vrf=ExpressionWrapper(
Coalesce(F("vrf_id"), FAKE_UUID),
output_field=UUIDField(),
)).filter(
Q(prefix_length__gt=OuterRef("prefix_length"))
& Q(network__gte=OuterRef("network"))
& Q(broadcast__lte=OuterRef("broadcast"))
& Q(maybe_vrf=ExpressionWrapper(
Coalesce(OuterRef("vrf_id"), FAKE_UUID),
output_field=UUIDField(),
))).order_by().
annotate(
fake_group_by=Value(1)
) # This is an ORM hack to remove the unwanted GROUP BY clause
.values("fake_group_by").annotate(
count=Count("*")).values("count")[:1],
output_field=IntegerField(),
),
)
class Profile(Model):
'''
A Crates user has access to the media on this server. The user may also be
allowed to connect his/her own crates server to this one.
This is a one-to-one relationship used to extend the existing user model without much effort.
'''
user = OneToOneField(User)
has_api_access = BooleanField(
default=False,
help_text="Can this user crawl this server from their crates server?")
api_key = UUIDField(
unique=True,
default=uuid4,
help_text="Key used to identify user's crates server",
)
#ip = GenericIPAddressField(help_text="IP address of the host")
user_server_url = URLField(
null=True,
blank=True,
help_text="API url of user's own crates server, if any",
)
user_server_api_key = UUIDField(
null=True,
blank=True,
help_text=
"API key of user's own crates server, if user has given you API access",
)
can_upload = BooleanField(
default=False,
help_text=
"Is the user allowed to push files to this crates server? Not implemented yet."
)
# some stats... (need revising and improvement)
bytes_inbound = IntegerField(default=0, editable=False)
bytes_outbound = IntegerField(default=0, editable=False)
object_count = IntegerField(default=0, editable=False)
bytes_available = IntegerField(default=0, editable=False)
bytes_total = IntegerField(default=0, editable=False)
objects_common = IntegerField(
default=0,
editable=False,
help_text="Mutual CAS objects. Good for data backup")
class Reminder(Model):
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
member = ForeignKey(Member)
reminder_subject = CharField(max_length=65)
reminder_message = CharField(max_length=150)
reminder_created_date = DateTimeField('reminder created on')
reminder_send_date = DateTimeField('send reminder on',
null=True,
blank=True)
reminder_sent_on_date = DateTimeField('reminder sent on',
null=True,
blank=True)
member_reminded_on_date = DateTimeField('member reminded on',
null=True,
blank=True)
def is_an_email(self):
if (self.member.member_email):
return True
return False
def is_an_SMS(self):
if (self.member.member_phone):
return True
return False
def __unicode__(self):
return unicode(self.id)
class RSModel(SafeDeleteModel):
updated_at = DateTimeField(auto_now=True)
created_at = DateTimeField(auto_now_add=True)
id = UUIDField(primary_key=True, default=uuid4, editable=False)
class Meta:
abstract = True
class Project(ActivatableCreateableModel):
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
project_name = CharField(max_length=100)
client = ForeignKey('clients.Client',
related_name='projects',
on_delete=DO_NOTHING)
lead_employee = ForeignKey('employees.Employee',
related_name='projects',
on_delete=DO_NOTHING)
project_status = ForeignKey('ProjectStatus',
related_name='projects',
on_delete=DO_NOTHING)
office = ForeignKey('employees.Office',
related_name='projects',
on_delete=DO_NOTHING)
requires_afe = BooleanField()
work_order = ForeignKey('WorkOrder',
related_name='projects',
on_delete=DO_NOTHING)
project_type = ForeignKey('ProjectType',
related_name='projects',
on_delete=DO_NOTHING)
def __str__(self):
return self.project_name
class Submission(BaseModel):
meeting_id = UUIDField()
meeting_type = ForeignKey(ContentType, on_delete=CASCADE)
meeting = GenericForeignKey('meeting_type', 'meeting_id')
member = ForeignKey(Member, on_delete=CASCADE, related_name='submissions')
status = PSIF(
choices=SubmissionStatus.CHOICES, default=SubmissionStatus.OPEN)
class Meta:
unique_together = ['member', 'meeting_type', 'meeting_id']
def is_open(self):
return self.status == SubmissionStatus.OPEN
def get_question_category(self):
if self.meeting_type.name == 'standup':
return QuestionCategory.STANDUP
elif self.meeting_type.name == 'checkin':
return QuestionCategory.CHECKIN
raise NotImplementedError('Unknown meeeting type!')
def get_questions(self):
return Question.objects.filter(category=self.get_question_category())
def close(self):
self.status = SubmissionStatus.CLOSED
self.save()
def submit(self):
self.status = SubmissionStatus.SUBMITTED
self.save()
class Model(DjangoModel):
id = UUIDField("ID", primary_key=True, editable=False, default=uuid4)
created_at = DateTimeField(auto_now_add=True)
updated_at = DateTimeField(auto_now=True)
class Meta:
abstract = True
class School(LogicalDeleteModel):
id = UUIDField(primary_key=True, default=uuid4, editable=False)
name = models.CharField(max_length=255)
code = models.CharField(max_length=5, unique=True)
def __str__(self):
return f"{self.code}-{self.name}"
class Test(Model):
name = CharField(max_length=20)
owner = ForeignKey(settings.AUTH_USER_MODEL,
null=True,
blank=True,
on_delete=CASCADE)
public = BooleanField(default=False)
date = DateField(null=True, blank=True)
datetime = DateTimeField(null=True, blank=True)
permission = ForeignKey('auth.Permission',
null=True,
blank=True,
on_delete=CASCADE)
# We can’t use the exact names `float` or `decimal` as database column name
# since it fails on MySQL.
a_float = FloatField(null=True, blank=True)
a_decimal = DecimalField(null=True,
blank=True,
max_digits=5,
decimal_places=2)
bin = BinaryField(null=True, blank=True)
ip = GenericIPAddressField(null=True, blank=True)
duration = DurationField(null=True, blank=True)
uuid = UUIDField(null=True, blank=True)
class Meta(object):
ordering = ('name', )
class Rule(Model):
"""Stores a rule's content and associated permissions."""
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
created = DateTimeField(auto_now_add=True, editable=False)
modified = DateTimeField(auto_now=True, editable=False)
# The rule creator is the first user to POST the rule to the system.
rule_creator = ForeignKey(to=User,
on_delete=SET_NULL,
null=True,
blank=True,
related_name="created_rules")
# Simple Properties
name = CharField(max_length=200)
description = CharField(max_length=1000)
# The set of editors can be modified by the creator.
editors = ManyToManyField(to=User, related_name="editable_rules")
# If a rule is forked, this will store a reference to the original rule
forked_from = ForeignKey("Rule", on_delete=SET_NULL, null=True, blank=True)
primary_content = ForeignKey("RuleContent",
null=True,
blank=True,
on_delete=SET_NULL)
class BaseModel(Model):
"""
Base
"""
id = UUIDField(primary_key=True, default=uuid4, editable=False)
time_created = DateTimeField(verbose_name="Created on",
auto_now_add=True,
null=True)
time_modified = DateTimeField(verbose_name="Last modified on",
auto_now=True,
null=True)
creator = ForeignKey("users.User",
verbose_name="Created by",
related_name="%(app_label)s_%(class)s_creator",
null=True,
blank=True,
on_delete=CASCADE)
last_modified_by = ForeignKey(
"users.User",
verbose_name="Last modified by",
related_name="%(app_label)s_%(class)s_last_modified",
null=True,
blank=True,
on_delete=CASCADE)
class Meta:
abstract = True
def save(self, *args, **kwargs):
if not self.time_created:
self.time_created = timezone.now()
self.time_modified = timezone.now()
return super(BaseModel, self).save(*args, **kwargs)
class Language(models.Model):
id = UUIDField(primary_key=True, default=uuid.uuid4)
doctor = ForeignKey("Doctor",
on_delete=models.PROTECT,
related_name="languages")
query_name = SlugField()
display_name = TextField()
class Asset(Model):
"""Top level class for entire class hierarchy"""
class Meta:
db_table = "asset"
"""Asset type can take following values:
- pipeline
- power line
- electric truss
"""
PIPELINE = 'PIP'
POWER_LINE = 'POW'
ELECTRIC_TRUSS = 'ELE'
TYPE_CHOICES = (
(PIPELINE, 'Pipeline'),
(POWER_LINE, 'Power line'),
(ELECTRIC_TRUSS, 'Electric truss'),
)
id = UUIDField(primary_key=True, default=uuid4, editable=False)
type = CharField(max_length=3,
choices=TYPE_CHOICES,
blank=False,
null=False)
name = CharField(max_length=120,
blank=False,
null=False,
default=default_asset_name)
created = DateTimeField(auto_now_add=True)
modified = DateTimeField(auto_now=True)
description = TextField(blank=True, null=True)
note = TextField(blank=True, null=True)
geometry = GeometryField(blank=True, null=True, srid=settings.DEFAULT_SRID)
class Anomaly(Model):
"""Some object of interest inside the frame"""
class Meta:
db_table = "anomaly"
"""Object type, up to now there's only one option:
- insulator
"""
INSULATOR = 'INS'
TYPE_CHOICES = ((INSULATOR, 'Insulator'), )
UNKNOWN = 'UNK'
STATUS_CHOICES = ((UNKNOWN, 'Unknown'), )
frame = ForeignKey(Frame, related_name='_anomalies', on_delete=CASCADE)
id = UUIDField(primary_key=True, default=uuid4, editable=False)
type = CharField(max_length=3, choices=TYPE_CHOICES)
status = CharField(max_length=3, choices=STATUS_CHOICES)
confidence = IntegerField(blank=False, null=False)
x_min = IntegerField(blank=False, null=False)
x_max = IntegerField(blank=False, null=False)
y_min = IntegerField(blank=False, null=False)
y_max = IntegerField(blank=False, null=False)
class RSGenericAddress(RSAddress):
object_id = UUIDField()
content_type = ForeignKey(ContentType, on_delete=CASCADE)
content_object = GenericForeignKey('content_type', 'object_id')
class Meta:
abstract = True
class UserEarnings(CreatedModified):
class TimePeriod(TextChoices):
ALL = 'all', _('All')
SEVEN_DAYS = '7d', _('7 Days')
THIRTY_DAYS = '30d', _('30 Days')
uuid = UUIDField(default=uuid.uuid4, editable=False, primary_key=True)
user = ForeignKey('users.User', on_delete=CASCADE)
repository = ForeignKey(Repository, on_delete=CASCADE)
time_period = CharField(max_length=8, choices=TimePeriod.choices)
total_amount = PositiveBigIntegerField(validators=[
MaxValueValidator(MAX_POINT_VALUE),
MinValueValidator(MIN_POINT_VALUE),
])
class Meta:
constraints = [
UniqueConstraint(fields=['repository', 'time_period', 'user'],
name='unique_repository_time_period_user')
]
default_related_name = 'user_earnings'
verbose_name_plural = 'user earnings'
def __str__(self):
return f'#{self.pk}: {self.user.email}/{self.repository}/{self.time_period}'
class BlogPost(Model):
guid = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
enabled = BooleanField(default=True)
title = CharField(max_length=200, blank=True, null=True)
slug = SlugField(max_length=200, blank=True, null=True)
pub_date = DateTimeField(blank=True, null=True)
creator = ForeignKey(BlogUser, blank=True, null=True, on_delete=DO_NOTHING)
category = ForeignKey(BlogCategory,
blank=True,
null=True,
on_delete=DO_NOTHING)
description = RichTextField(blank=True, null=True)
content = RichTextField(blank=True, null=True)
guid_is_permalink = BooleanField(default=True)
class Meta:
verbose_name = "Post"
verbose_name_plural = "Posts"
def __str__(self):
return self.title if self.title else "Blog Post"
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.title)
super(BlogPost, self).save(*args, **kwargs)
class Command(Model):
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
cycle_duration = PositiveSmallIntegerField()
creation_time = DateTimeField(auto_now=True)
class Meta:
indexes = (Index(fields=['creation_time']), )
class BaseModel(Model):
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
created_at = DateTimeField(auto_now_add=True, db_index=True)
updated_at = DateTimeField(auto_now=True, db_index=True)
class Meta:
abstract = True
class Event(models.Model):
"""Event instance which may result in one or more Alerts."""
timestamp = models.DateTimeField(auto_now=True)
eventid = UUIDField(default=uuid.uuid4, editable=False)
severity = models.IntegerField(validators=[MinValueValidator(0),
MaxValueValidator(100)])
log_message = models.TextField(null=True, blank=True)
context = PickledObjectField()
trigger_result = PickledObjectField()
def __unicode__(self):
return '<Event %s/%s (%s)>' % (self.id, self.eventid, self.timestamp)
def __repr__(self):
return unicode(self)
def get_details(self):
"""Return details in a string"""
msg = []
fmt = '{0:15}: {1}'
msg.append(fmt.format('ID', self.id))
msg.append(fmt.format('EventID', self.eventid))
msg.append(fmt.format('Severity', self.severity))
msg.append(fmt.format('Timestamp', self.timestamp))
msg.append(fmt.format('Log Message', self.log_message))
msg.append(fmt.format('Trigger Result', self.trigger_result))
msg.append(fmt.format('Context', self.context))
alerts = self.alert_set.all()
if alerts:
msg.append('')
msg.append('Associated Alerts:')
for a in alerts:
msg.append(a.get_details())
return '\n'.join(msg)
class Token(Model):
class Meta:
get_latest_by = 'expires'
verbose_name = '[Access] Authentication Token'
verbose_name_plural = '[Access] Authentication Tokens'
expires = DateTimeField('Token Expire Time', null=True, blank=True)
uid = UUIDField('Token UUID',
primary_key=True,
default=uuid4,
editable=False)
def __str__(self):
if self.expires is not None:
return '[Token] %s (%s)' % (str(
self.uid), self.expires.strftime('%m/%d/%y %H:%M'))
return '[Token] %s (No Expire)' % str(self.uid)
def __len__(self):
if self.expires is not None:
return max((self.expires - now()).seconds, 0)
return 0
def __bool__(self):
return len(self) > 0 or self.expires is None
class UserProfile(Model):
id = UUIDField(primary_key=True,
default=uuid.uuid4,
editable=False,
unique=True)
user = OneToOneField(User, on_delete=CASCADE, related_name='profile')
role = CharField(max_length=1,
choices=UserRole.CHOICES,
default=UserRole.USUAL)
is_system = BooleanField(default=False)
login = CharField(null=False, unique=True, max_length=255)
name = CharField(null=False, max_length=255)
updated_at = DateTimeField(auto_now=True, editable=False)
created_at = DateTimeField(auto_now_add=True, editable=False)
is_active = BooleanField(default=True)
objects = Manager()
active = ActiveObjectManager()
system_user = SystemUserObjectManager()
class Meta:
verbose_name = "User Profile"
ordering = ('pk', )
indexes = [Index(fields=['is_system'])]
def __str__(self):
return self.login
@staticmethod
def get_profile_by_user(user):
return UserProfile.objects.filter(user=user.id).first()
class Test(Model):
name = CharField(max_length=20)
owner = ForeignKey(settings.AUTH_USER_MODEL,
null=True,
blank=True,
on_delete=SET_NULL)
public = BooleanField(default=False)
date = DateField(null=True, blank=True)
datetime = DateTimeField(null=True, blank=True)
permission = ForeignKey('auth.Permission',
null=True,
blank=True,
on_delete=PROTECT)
# We can’t use the exact names `float` or `decimal` as database column name
# since it fails on MySQL.
a_float = FloatField(null=True, blank=True)
a_decimal = DecimalField(null=True,
blank=True,
max_digits=5,
decimal_places=2)
bin = BinaryField(null=True, blank=True)
ip = GenericIPAddressField(null=True, blank=True)
duration = DurationField(null=True, blank=True)
uuid = UUIDField(null=True, blank=True)
try:
from django.db.models import JSONField
json = JSONField(null=True, blank=True)
except ImportError:
pass
class Meta:
ordering = ('name', )
class Game(Model):
uuid = UUIDField(default=uuid.uuid4, primary_key=True)
white_player = ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=CASCADE,
related_name="white_player",
null=True,
)
black_player = ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=CASCADE,
related_name="black_player",
null=True,
)
created_at = DateTimeField(auto_now_add=True)
started_at = DateTimeField(null=True)
finished_at = DateTimeField(null=True)
result = OneToOneField(
Result,
on_delete=CASCADE,
)
board = OneToOneField(
Board,
on_delete=CASCADE,
)
class User(AbstractUser):
avatar = ImageField(blank=True,
default='default/default-user.jpg',
upload_to=user_directory_path)
birth_date = DateField(null=True, blank=True, default=None)
email = EmailField('email', unique=True, blank=True, null=False)
phone = CharField(max_length=20, blank=True, default=None, null=True)
thumbnail = ImageField(blank=True, default='default/default-user.jpg')
is_verified = BooleanField('verified', default=False)
verification_uuid = UUIDField('Unique Verification UUID',
default=uuid.uuid4)
@classmethod
def create(cls, **kwargs):
new_user = cls()
new_user.birth_date = kwargs.get('birth_date') if kwargs.get(
'birth_date') else None
new_user.email = kwargs.get('email') if kwargs.get('email') else None
new_user.first_name = kwargs.get('first_name') if kwargs.get(
'first_name') else None
new_user.last_name = kwargs.get('last_name') if kwargs.get(
'last_name') else None
new_user.password = make_password(kwargs.get('password'))
new_user.phone = kwargs.get('phone') if kwargs.get('phone') else None
new_user.username = kwargs.get('username')
return new_user
def __str__(self):
return self.username if self.username else '%s %s' % (self.first_name,
self.last_name)
def test_update_UUIDField_using_Value(self):
UUID.objects.create()
UUID.objects.update(
uuid=Value(uuid.UUID('12345678901234567890123456789012'),
output_field=UUIDField()))
self.assertEqual(UUID.objects.get().uuid,
uuid.UUID('12345678901234567890123456789012'))
def _handle_pk_field(queryset):
pk = queryset.model._meta.pk
if isinstance(pk, ForeignKey):
return _handle_pk_field(pk.target_field)
if isinstance(
pk,
(
IntegerField,
AutoField,
BigIntegerField,
PositiveIntegerField,
PositiveSmallIntegerField,
SmallIntegerField,
),
):
return partial(Cast, output_field=BigIntegerField())
if isinstance(pk, UUIDField):
if connection.features.has_native_uuid_field:
return partial(Cast, output_field=UUIDField())
return partial(
Replace,
text=Value('-'),
replacement=Value(''),
output_field=CharField(),
)
return None
