def __init__(self, to, to_field=None, **kwargs):
try:
to_name = to._meta.object_name.lower()
except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
assert isinstance(to, basestring), "OneToOneField(%r) is invalid. First parameter to OneToOneField must be either a model, a model name, or the string %r" % (to, RECURSIVE_RELATIONSHIP_CONSTANT)
else:
to_field = to_field or to._meta.pk.name
kwargs['verbose_name'] = kwargs.get('verbose_name', '')
if kwargs.has_key('edit_inline_type'):
import warnings
warnings.warn("edit_inline_type is deprecated. Use edit_inline instead.")
kwargs['edit_inline'] = kwargs.pop('edit_inline_type')
kwargs['rel'] = OneToOneRel(to, to_field,
num_in_admin=kwargs.pop('num_in_admin', 0),
edit_inline=kwargs.pop('edit_inline', False),
related_name=kwargs.pop('related_name', None),
limit_choices_to=kwargs.pop('limit_choices_to', None),
lookup_overrides=kwargs.pop('lookup_overrides', None),
raw_id_admin=kwargs.pop('raw_id_admin', False))
kwargs['primary_key'] = True
IntegerField.__init__(self, **kwargs)
self.db_index = True
def test_check_constraints(self):
"""
Tests creating/deleting CHECK constraints
"""
# Create the tables
with connection.schema_editor() as editor:
editor.create_model(Author)
# Ensure the constraint exists
constraints = connection.introspection.get_constraints(connection.cursor(), Author._meta.db_table)
for name, details in constraints.items():
if details["columns"] == ["height"] and details["check"]:
break
else:
self.fail("No check constraint for height found")
# Alter the column to remove it
new_field = IntegerField(null=True, blank=True)
new_field.set_attributes_from_name("height")
with connection.schema_editor() as editor:
editor.alter_field(Author, Author._meta.get_field_by_name("height")[0], new_field, strict=True)
constraints = connection.introspection.get_constraints(connection.cursor(), Author._meta.db_table)
for name, details in constraints.items():
if details["columns"] == ["height"] and details["check"]:
self.fail("Check constraint for height found")
# Alter the column to re-add it
with connection.schema_editor() as editor:
editor.alter_field(Author, new_field, Author._meta.get_field_by_name("height")[0], strict=True)
constraints = connection.introspection.get_constraints(connection.cursor(), Author._meta.db_table)
for name, details in constraints.items():
if details["columns"] == ["height"] and details["check"]:
break
else:
self.fail("No check constraint for height found")
def test_alter_implicit_id_to_explicit(self):
"""
Should be able to convert an implicit "id" field to an explicit "id"
primary key field.
"""
with connection.schema_editor() as editor:
editor.create_model(Author)
new_field = IntegerField(primary_key=True)
new_field.set_attributes_from_name("id")
new_field.model = Author
with connection.schema_editor() as editor:
editor.alter_field(
Author,
Author._meta.get_field_by_name("id")[0],
new_field,
strict=True,
)
def test_add_field(self):
"""
Tests adding fields to models
"""
# Create the table
with connection.schema_editor() as editor:
editor.create_model(Author)
# Ensure there's no age field
columns = self.column_classes(Author)
self.assertNotIn("age", columns)
# Add the new field
new_field = IntegerField(null=True)
new_field.set_attributes_from_name("age")
with connection.schema_editor() as editor:
editor.add_field(Author, new_field)
# Ensure the field is right afterwards
columns = self.column_classes(Author)
self.assertEqual(columns["age"][0], "IntegerField")
self.assertEqual(columns["age"][1][6], True)
def test_spanning_relations_with_custom_lookup_in_search_fields(self):
hype = Group.objects.create(name='The Hype')
concert = Concert.objects.create(name='Woodstock', group=hype)
vox = Musician.objects.create(name='Vox', age=20)
Membership.objects.create(music=vox, group=hype)
# Register a custom lookup on IntegerField to ensure that field
# traversing logic in ModelAdmin.get_search_results() works.
IntegerField.register_lookup(Exact, 'exactly')
try:
m = ConcertAdmin(Concert, custom_site)
m.search_fields = ['group__members__age__exactly']
request = self.factory.get('/', data={SEARCH_VAR: '20'})
cl = m.get_changelist_instance(request)
self.assertCountEqual(cl.queryset, [concert])
request = self.factory.get('/', data={SEARCH_VAR: '21'})
cl = m.get_changelist_instance(request)
self.assertCountEqual(cl.queryset, [])
finally:
IntegerField._unregister_lookup(Exact, 'exactly')
def test_alter_implicit_id_to_explicit(self):
"""
Should be able to convert an implicit "id" field to an explicit "id"
primary key field.
"""
with connection.schema_editor() as editor:
editor.create_model(Author)
new_field = IntegerField(primary_key=True)
new_field.set_attributes_from_name("id")
new_field.model = Author
with connection.schema_editor() as editor:
editor.alter_field(
Author,
Author._meta.get_field("id"),
new_field,
strict=True,
)
# This will fail if DROP DEFAULT is inadvertently executed on this
# field which drops the id sequence, at least on PostgreSQL.
Author.objects.create(name='Foo')
def get_chat_sessions(self, request, enroll_code, courseUnit):
return Chat.objects.filter(
enroll_code=enroll_code,
user=request.user,
instructor=courseUnit.course.addedBy,
is_live=False,
is_test=self.tester_mode,
is_preview=False
).annotate(
not_finished=Case(
When(state_id__isnull=True, then=0),
When(state_id__isnull=False, then=1),
default=0,
output_field=IntegerField())
).order_by('-not_finished', '-last_modify_timestamp')
class StrIndex(Func):
"""
Return a positive integer corresponding to the 1-indexed position of the
first occurrence of a substring inside another string, or 0 if the
substring is not found.
"""
function = 'INSTR'
arity = 2
output_field = IntegerField()
def as_postgresql(self, compiler, connection, **extra_context):
return super().as_sql(compiler,
connection,
function='STRPOS',
**extra_context)
def test_alter_field_nullability_change_raise_not_support_error(self):
"""
Tests altering nullability of existing field in table
"""
with DatabaseSchemaEditor(self.connection) as schema_editor:
schema_editor.execute = mock.MagicMock()
def constraint_names(*args, **kwargs):
return ["num_unique"]
schema_editor._constraint_names = constraint_names
old_field = IntegerField(null=True)
old_field.set_attributes_from_name("num")
new_field = IntegerField()
new_field.set_attributes_from_name("author_num")
with self.assertRaises(NotSupportedError):
schema_editor.alter_field(Author, old_field, new_field)
class Transcript(models.Model):
episode_number = IntegerField(primary_key=True)
date_published = CharField(max_length=10)
link_to_mp3 = models.CharField(max_length=242)
link_to_podcast = models.CharField(max_length=242)
idd = models.CharField(max_length=240)
status = models.CharField(max_length=245)
text = models.TextField()
words = models.JSONField()
class Meta:
verbose_name_plural = 'Transcripts'
def __str__(self):
return self.date_published
class Count(Aggregate):
function = 'COUNT'
name = 'Count'
output_field = IntegerField()
allow_distinct = True
def __init__(self, expression, filter=None, **extra):
if expression == '*':
expression = Star()
if isinstance(expression, Star) and filter is not None:
raise ValueError('Star cannot be used with filter. Please specify a field.')
super().__init__(expression, filter=filter, **extra)
def convert_value(self, value, expression, connection):
return 0 if value is None else value
class Card(Model):
class Meta:
ordering = ["card_no"]
card_no = IntegerField(blank=True, null=True)
card_set = ForeignKey(CardSet)
name = CharField(max_length=255)
url = URLField()
card_type = ForeignKey(CardType)
rarity = ForeignKey(Rarity)
@property
def instances(self):
return self.cardinstance_set.all().order_by("variant")
def test_alter_field_change_null_with_multiple_index_error(self):
"""
Tests altering nullability of field with multiple index not supported
"""
with DatabaseSchemaEditor(self.connection) as schema_editor:
schema_editor.execute = mock.MagicMock()
def constraint_names(*args, **kwargs):
return ["num_unique", "dummy_index"]
schema_editor._constraint_names = constraint_names
old_field = IntegerField(null=True, db_index=True)
old_field.set_attributes_from_name("num")
new_field = IntegerField()
new_field.set_attributes_from_name("author_num")
with self.assertRaises(NotSupportedError):
schema_editor.alter_field(Author, old_field, new_field)
def test_convert_values_to_handle_null_value(self):
database_operations = DatabaseOperations(connection)
self.assertEqual(
None,
database_operations.convert_values(None,
AutoField(primary_key=True)))
self.assertEqual(None,
database_operations.convert_values(None, DateField()))
self.assertEqual(
None, database_operations.convert_values(None, DateTimeField()))
self.assertEqual(
None, database_operations.convert_values(None, DecimalField()))
self.assertEqual(
None, database_operations.convert_values(None, IntegerField()))
self.assertEqual(None,
database_operations.convert_values(None, TimeField()))
class mergetask(models.Model):
taskid = CharField(max_length=100, primary_key=True)
createtime = DateTimeField()
src1 = CharField(max_length=100)
src2 = CharField(max_length=100)
dst = CharField(max_length=100)
# 1 Not transcoding, 2 transcoding ,3 transcoding sucess , 8 transcoding Failed
status = IntegerField()
def __unicode__(self):
# 在Python3中使用 def __str__(self)
return self.taskid
def getTask(self):
return self.src1
class Ord(Transform):
function = "ASCII"
lookup_name = "ord"
output_field = IntegerField()
def as_mysql(self, compiler, connection, **extra_context):
return super().as_sql(compiler,
connection,
function="ORD",
**extra_context)
def as_sqlite(self, compiler, connection, **extra_context):
return super().as_sql(compiler,
connection,
function="UNICODE",
**extra_context)
class Ord(Transform):
function = 'ASCII'
lookup_name = 'ord'
output_field = IntegerField()
def as_mysql(self, compiler, connection, **extra_context):
return super().as_sql(compiler,
connection,
function='ORD',
**extra_context)
def as_sqlite(self, compiler, connection, **extra_context):
return super().as_sql(compiler,
connection,
function='UNICODE',
**extra_context)
class Source(models.Model):
TYPE_PDF = 1
TYPE_YOUTUBE = 2
TYPE_HTML5VIDEO = 3
TYPE_HTML5 = 4
TYPES = ((TYPE_PDF, "PDF"), (TYPE_YOUTUBE, "YOUTUBE"), (TYPE_HTML5VIDEO, "HTML5VIDEO"), (TYPE_HTML5, "HTML5"))
title = CharField(max_length=255, default="untitled") # old: title text
submittedby = ForeignKey(User, blank=True, null=True) # old: submittedby integer
numpages = IntegerField(default=0)
w = IntegerField(default=0) # old: ncols integer
h = IntegerField(default=0) # old: nrows integer
rotation = IntegerField(default=0) # new
version = IntegerField(default=0) #incremented when adding src
type = IntegerField(choices=TYPES, default=TYPE_PDF)
x0 = IntegerField(default=0) #x-coordinate of lower-left corner of trimbox
y0 = IntegerField(default=0) #y-coordinate of lower-left corner of trimbox
def __unicode__(self):
return "%s %s: %s" % (self.__class__.__name__,self.id, self.title)
class Count(abc.ABC, Func):
"""
Custom SQL `COUNT` function without `GROUP BY`.
This SQL `COUNT` directly inherits from Func() instead of Aggregate
like django's default COUNT function. This way the `GROUP BY` order
isn't added.
"""
name = "Count"
function = "COUNT"
output_field = IntegerField()
allow_distinct = True
def __init__(self, expression, **extra):
"""
Overridden to check for filtering star expressions.
:param expression: The SQL function expression
:type expression: django.db.models.expressions.Expression | str
:param extra: Additional keyword arguments to pass on
:type extra: any
"""
expression = Star() if expression == "*" else expression
has_filter = "filter" in extra and extra["filter"] is not None
if isinstance(expression, Star) and has_filter:
raise ValueError("Star cannot be used with filter.")
Func.__init__(self, expression, filter=filter, **extra)
def convert_value(self, value, expression, connection):
"""
Sanitize NULL value's.
:param value: The value to sanitize
:type value: int | None
:param expression: The currently used function expression
:type expression: django.db.models.expressions.Expression
:param connection: The current connection proxy
:type connection: django.db.DefaultConnectionProxy
"""
return 0 if value is None else value
def list(self, request, *args, **kwargs):
if request.query_params.get('offline') == 'true':
queryset = self.filter_queryset(Asset.objects.all().annotate(
rack_letter=Cast('asset_number', CharField())).annotate(
numstr_in_rack=Cast('asset_number', CharField())).annotate(
number_in_racknum=Cast('asset_number', IntegerField(
))).exclude(datacenter__is_offline=False))
# Asset.objects.all() \
# .annotate(rack_letter=Substr('rack__rack_number', 1, 1)) \
# .annotate(numstr_in_rack=Substr('rack__rack_number', 2))
# queryset = queryset.annotate(number_in_racknum=Cast('numstr_in_rack', IntegerField()))
# self.filter_queryset(self.get_queryset())
if request.query_params.get('export') == 'true':
if request.query_params.get('np') == 'true':
return export_network_ports(queryset)
return export_assets(queryset)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
if not request.query_params.get('offline') == 'true':
queryset = self.filter_queryset(
self.get_queryset()).exclude(datacenter__is_offline=True)
if request.query_params.get('export') == 'true':
queryset = self.filter_queryset(self.get_queryset())
if request.query_params.get('np') == 'true':
return export_network_ports(queryset)
return export_assets(queryset)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
if request.query_params.get('export') == 'true':
queryset = self.filter_queryset(self.get_queryset())
if request.query_params.get('np') == 'true':
return export_network_ports(queryset)
return export_assets(queryset)
return super().list(self, request, *args, **kwargs)
class Answer(models.Model):
id = CharField(max_length=20, primary_key=True, db_column='id')
question_id = ForeignKey(Question,
db_column='QUESTID',
default='',
on_delete=models.CASCADE)
assignment_id = ForeignKey(Assignment,
db_column='ASNID',
default='',
on_delete=models.CASCADE)
answer = IntegerField(db_column='ANSWER',
default=1,
validators=[validate_choice])
class Meta:
db_table = "ANSWER"
unique_together = (("question_id", "assignment_id"), )
class Extract(TimezoneMixin, Transform):
lookup_name = None
output_field = IntegerField()
def __init__(self, expression, lookup_name=None, tzinfo=None, **extra):
if self.lookup_name is None:
self.lookup_name = lookup_name
if self.lookup_name is None:
raise ValueError('lookup_name must be provided')
self.tzinfo = tzinfo
super().__init__(expression, **extra)
def as_sql(self, compiler, connection):
sql, params = compiler.compile(self.lhs)
lhs_output_field = self.lhs.output_field
if isinstance(lhs_output_field, DateTimeField):
tzname = self.get_tzname()
sql = connection.ops.datetime_extract_sql(self.lookup_name, sql, tzname)
elif isinstance(lhs_output_field, DateField):
sql = connection.ops.date_extract_sql(self.lookup_name, sql)
elif isinstance(lhs_output_field, TimeField):
sql = connection.ops.time_extract_sql(self.lookup_name, sql)
elif isinstance(lhs_output_field, DurationField):
if not connection.features.has_native_duration_field:
raise ValueError('Extract requires native DurationField database support.')
sql = connection.ops.time_extract_sql(self.lookup_name, sql)
else:
# resolve_expression has already validated the output_field so this
# assert should never be hit.
assert False, "Tried to Extract from an invalid type."
return sql, params
def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
copy = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
field = copy.lhs.output_field
if not isinstance(field, (DateField, DateTimeField, TimeField, DurationField)):
raise ValueError(
'Extract input expression must be DateField, DateTimeField, '
'TimeField, or DurationField.'
)
# Passing dates to functions expecting datetimes is most likely a mistake.
if type(field) == DateField and copy.lookup_name in ('hour', 'minute', 'second'):
raise ValueError(
"Cannot extract time component '%s' from DateField '%s'. " % (copy.lookup_name, field.name)
)
return copy
class Img(Model):
id = BigAutoField(verbose_name='ID', primary_key=True)
md5 = CharField(verbose_name='MD5', max_length=32, null=False)
src = CharField(
verbose_name='路径',
max_length=255,
null=False,
)
is_deleted = BooleanField(verbose_name='已经删除',
null=False,
default=False,
blank=True)
size = IntegerField(verbose_name='体积（Byte）', null=False)
updater = BigIntegerField(null=False, verbose_name='作者账号') # user外键
create_time = DateTimeField(null=False,
verbose_name='创建时间',
auto_now_add=True)
class Location(models.Model): # old: nb2_location
source = ForeignKey(Source) # old: id_source integer
version = IntegerField(default=1)
ensemble = ForeignKey(Ensemble) # old: id_ensemble integer
section = ForeignKey(Section, null=True)
x = IntegerField()
y = IntegerField()
w = IntegerField()
h = IntegerField()
page = IntegerField()
def __unicode__(self):
return "%s %s: on source %s - page %s " % (self.__class__.__name__,self.id, self.source_id, self.page)
class About(models.Model):
title = CharField(max_length=1000, blank=True, default="")
subtitle = CharField(max_length=1000, blank=True, default="")
info = TextField(blank=True, default="")
index = IntegerField(default=0)
externURL = URLField(verbose_name="Extern link", default="", blank=True)
image = ImageField(upload_to="about_images", null=True)
largeImage = ImageSpecField(source="image",
processors=[ResizeToFill(1920, 1080)],
format='JPEG',
options={
'quality': 75,
'progressive': True
})
mediumImage = ImageSpecField(source="image",
processors=[ResizeToFill(1280, 720)],
format='JPEG',
options={
'quality': 75,
'progressive': True
})
smallImage = ImageSpecField(source="image",
processors=[ResizeToFill(640, 360)],
format='JPEG',
options={
'quality': 75,
'progressive': True
})
def getShortDescription(self):
return str(self.title + " - " + self.subtitle[:50] + "...")
def toHTML(self):
return self.info.replace("<p", "<p class=\"rl-document__paragraph\"")\
.replace("<span", "<span class=\"rl-document__title\"")
def __unicode__(self):
return self.title + " - " + self.subtitle
def test_convert_values_to_handle_null_value(self):
from django.db.backends.sqlite3.base import DatabaseOperations
database_operations = DatabaseOperations(connection)
self.assertEqual(
None,
database_operations.convert_values(None,
AutoField(primary_key=True)))
self.assertEqual(None,
database_operations.convert_values(None, DateField()))
self.assertEqual(
None, database_operations.convert_values(None, DateTimeField()))
self.assertEqual(
None, database_operations.convert_values(None, DecimalField()))
self.assertEqual(
None, database_operations.convert_values(None, IntegerField()))
self.assertEqual(None,
database_operations.convert_values(None, TimeField()))
class Profile(QuicksellModel): """User profile info.""" user = OneToOneField( User, related_name='_profile', primary_key=True, editable=False, on_delete=CASCADE ) uuid = UUIDField(default=uuid.uuid4, unique=True, editable=False) date_created = DateField(default=date.today, editable=False) full_name = CharField(max_length=100, blank=True) about = TextField(blank=True) online = BooleanField(default=True) rating = IntegerField(default=0) avatar = ImageField(null=True, blank=True, upload_to='images/avatars') location = ForeignKey(**location_fk_kwargs) def __str__(self): return str(self.user) + "'s profile."
class Enlace(models.Model):
titulo = models.CharField(max_length=140)
enlace = models.URLField()
votos = IntegerField(default=0)
categorias = models.ForeignKey(Categoria)
usuario = models.ForeignKey(User)
timestamp = models.DateTimeField(auto_now_add=True)
def __unicode__(self):
return "%s - %s" % (self.titulo, self.enlace)
def mis_votos_en_imagen_rosada(self):
return 'http://placehold.it/200x100/E8117F/ffffff/&text=%d+votos' % self.votos
def es_popular(self):
return self.votos > 1
es_popular.boolean = True
class Ensemble(models.Model): # old: ensemble
SECTION_ASSGT_NULL = 1
SECTION_ASSGT_RAND = 2
SECTION_ASSGT_TYPES = ((SECTION_ASSGT_NULL, "NULL"), (SECTION_ASSGT_RAND,
"RANDOM"))
name = CharField(max_length=255) # old: name text
description = CharField(max_length=255, default="No description available")
allow_staffonly = BooleanField(
default=True,
verbose_name="Allow users to write 'staff-only' comments")
allow_anonymous = BooleanField(
default=True, verbose_name="Allow users to write anonymous comments")
allow_tag_private = BooleanField(
default=True,
verbose_name="Allow users to make comments private to tagged users only"
)
allow_guest = BooleanField(
default=False,
verbose_name="Allow guests (i.e. non-members) to access the site")
invitekey = CharField(max_length=63, blank=True, null=True) # new
use_invitekey = BooleanField(
default=True,
verbose_name=
"Allow users who have the 'subscribe link' to register by themselves")
allow_download = BooleanField(
default=True, verbose_name="Allow users to download the PDFs")
allow_ondemand = BooleanField(
default=False,
verbose_name=
"Allow users to add any PDF accessible on the internet by pointing to its URL"
)
default_pause = BooleanField(
default=False, verbose_name="Pause on staff Video comments by default")
section_assignment = IntegerField(choices=SECTION_ASSGT_TYPES,
default=SECTION_ASSGT_NULL,
null=True)
metadata = TextField(null=True,
blank=True) #data in json format to help processing.
def __unicode__(self):
return "%s %s: %s" % (self.__class__.__name__, self.id, self.name)
class Meta:
ordering = ["id"]
class Reminder(models.Model):
project_id = CharField(null=False, blank=False, max_length=264)
day = IntegerField(null=True, blank=True)
message = CharField(max_length=160)
reminder_mode = CharField(null=False, blank=False, max_length=20, default=ReminderMode.BEFORE_DEADLINE)
organization = ForeignKey(Organization)
def to_dict(self):
return {'day': self.day, 'message': self.message, 'reminder_mode': self.reminder_mode, 'id': self.id}
def void(self, void=True):
self.voided = void
self.save()
def should_be_send_on(self, deadline, on_date):
assert isinstance(on_date, date)
deadline_date = self._get_applicapable_deadline_date(deadline, on_date)
return on_date == deadline_date + timedelta(days=self._delta())
def get_sender_list(self, project, on_date, dbm):
if not project.reminder_and_deadline['should_send_reminder_to_all_ds']:
deadline_date = self._get_applicapable_deadline_date(project.deadline(), on_date)
return project.get_data_senders_without_submissions_for(deadline_date, dbm)
return project.get_data_senders(dbm)
def _delta(self):
if self.reminder_mode == ReminderMode.ON_DEADLINE:
return 0
if self.reminder_mode == ReminderMode.BEFORE_DEADLINE:
return -self.day
if self.reminder_mode == ReminderMode.AFTER_DEADLINE:
return self.day
def _get_applicapable_deadline_date(self, deadline, on_date):
if self.reminder_mode == ReminderMode.BEFORE_DEADLINE:
return deadline.next_deadline(on_date)
else:
return deadline.current_deadline(on_date)
def log(self, dbm, project_id, date, to_number, sent_status='sent', number_of_sms=0):
log = ReminderLog(dbm=dbm, reminder=self, project_id=project_id, date=date, sent_status=sent_status,
number_of_sms=number_of_sms, to_number=to_number)
log.save()
return log
def get_next_id(queryset: QuerySet, id_field: Field, max_len: int):
"""
Fetch the next sequential ID value by incrementing the maximum ID value in a
queryset.
:param queryset QuerySet: The queryset to get the next sequential ID from
:param id_field Field: The ID field to consider
:param max_len int: The maximum length of an ID value
"""
if not queryset:
return "1".zfill(max_len)
return (queryset.annotate(next_id=Func(
Cast(F(id_field.name), IntegerField()) + 1,
Value(f"FM{'0' * max_len}"),
function="TO_CHAR",
output_field=id_field,
), ).exclude(next_id__in=queryset.values(id_field.name), ).order_by(
id_field.name).first().next_id)
def xml_to_field(field_type, **kwargs):
if field_type == 'int':
#TODO fix max_length
field = IntegerField(max_length=MAX_LENGHT_INT, **kwargs)
if field_type == 'char':
#TODO fix max_length
field = CharField(max_length=MAX_LENGHT_CHAR, **kwargs)
if field_type == 'text':
field = TextField(**kwargs)
if field_type == 'boolean':
field = BooleanField(**kwargs)
if field_type == 'date':
field = DateField(**kwargs)
if field_type == 'datetime':
field = DateTimeField(**kwargs)
if field_type == 'float':
field = FloatField(**kwargs)
return field
class RBACSync(Model):
"""A row in this table denotes a change that requires information RBAC
micro-service to be updated.
Typically this will be populated by a trigger within the database. A
listeners in regiond will be notified and consult the un-synced records
in this table. This way we can consistently publish RBAC information to the
RBAC service in an HA environment.
"""
class Meta(DefaultMeta):
"""Default meta."""
objects = RBACSyncManager()
action = CharField(
editable=False, max_length=6, null=False, blank=True,
choices=RBAC_ACTION_CHOICES, default=RBAC_ACTION.FULL,
help_text="Action that should occur on the RBAC service.")
# An '' string is used when action is 'full'.
resource_type = CharField(
editable=False, max_length=255, null=False, blank=True,
help_text="Resource type that as been added/updated/removed.")
# A `None` is used when action is 'full'.
resource_id = IntegerField(
editable=False, null=True, blank=True,
help_text="Resource ID that has been added/updated/removed.")
# A '' string is used when action is 'full'.
resource_name = CharField(
editable=False, max_length=255, null=False, blank=True,
help_text="Resource name that has been added/updated/removed.")
# This field is informational.
created = DateTimeField(
editable=False, null=False, auto_now=False, auto_now_add=True)
# This field is informational.
source = CharField(
editable=False, max_length=255, null=False, blank=True,
help_text="A brief explanation what changed.")
class Comment(models.Model): # old: nb2_comment
TYPES = ((1, "Private"), (2, "Staff"), (3, "Class"))
location = ForeignKey(Location) # old: id_location integer
parent = ForeignKey('self', null=True) # old: id_parent integer
author = ForeignKey(User) # old: id_author integer,
ctime = DateTimeField(default=datetime.now) # old: ctime timestamp
body = TextField(blank=True, null=True)
type = IntegerField(choices=TYPES)
signed = BooleanField(default=True) # old: signed integer DEFAULT 0,
deleted = BooleanField(default=False) # old: vis_status integer DEFAULT 0
moderated = BooleanField(default=False)
def __unicode__(self):
return "%s %s: %s " % (self.__class__.__name__,self.id, self.body[:50])
@property
def created(self):
if (timezone.is_naive(self.ctime)):
return str(calendar.timegm(pytz.utc.localize(self.ctime).timetuple()))
else:
return str(calendar.timegm(self.ctime.astimezone(pytz.utc).timetuple()))
class DomainName(Model):
"""Domain Names."""
ip_address = GenericIPAddressField(protocol='IPv4', verbose_name='IP Address')
domain_name = CharField(max_length=100, verbose_name='Domain Name')
sr_number = IntegerField(null=True, verbose_name='SR Number', db_column='ticket_id')
def __str__(self):
return 'DNS Record: ' + str(self.ip_address)
@property
def domain_name_request(self):
if self.sr_number:
# TODO: Update to use updated srsconnector
# return DomainNameRequest.objects.get(ticket_id=self.sr_number)
return None
return None
class Meta:
verbose_name = 'Domain Name'
def filter_products_by_stock_availability(qs, stock_availability,
channel_slug):
allocations = (Allocation.objects.values("stock_id").filter(
quantity_allocated__gt=0,
stock_id=OuterRef("pk")).values_list(Sum("quantity_allocated")))
allocated_subquery = Subquery(queryset=allocations,
output_field=IntegerField())
stocks = (Stock.objects.for_channel(channel_slug).filter(
quantity__gt=Coalesce(allocated_subquery, 0)).values(
"product_variant_id"))
variants = ProductVariant.objects.filter(
Exists(stocks.filter(
product_variant_id=OuterRef("pk")))).values("product_id")
if stock_availability == StockAvailability.IN_STOCK:
qs = qs.filter(Exists(variants.filter(product_id=OuterRef("pk"))))
if stock_availability == StockAvailability.OUT_OF_STOCK:
qs = qs.filter(~Exists(variants.filter(product_id=OuterRef("pk"))))
return qs
def __new__(cls, name, bases, attrs):
super_new = super(ModelBase, cls).__new__
parents = [b for b in bases if isinstance(b, ModelBase)]
if not parents:
# If this isn't a subclass of Model, don't do anything special.
return super_new(cls, name, bases, attrs)
# Create the class.
module = attrs.pop('__module__')
new_class = super_new(cls, name, bases, {'__module__': module})
attr_meta = attrs.pop('Meta', None)
abstract = getattr(attr_meta, 'abstract', False)
mat_view = getattr(attr_meta, 'materialized_view', False)
leaf = False
if mat_view and abstract:
raise TypeError("A model cannot be 'abstract' and 'materialized_view' at the same time.")
if not attr_meta:
meta = getattr(new_class, 'Meta', None)
else:
meta = attr_meta
base_meta = getattr(new_class, '_meta', None)
if getattr(meta, 'app_label', None) is None:
# Figure out the app_label by looking one level up.
# For 'django.contrib.sites.models', this would be 'sites'.
model_module = sys.modules[new_class.__module__]
kwargs = {"app_label": model_module.__name__.split('.')[-2]}
else:
kwargs = {}
new_class.add_to_class('_meta', Options(meta, **kwargs))
if not abstract:
new_class.add_to_class('DoesNotExist', subclass_exception('DoesNotExist',
tuple(x.DoesNotExist
for x in parents if hasattr(x, '_meta') and not x._meta.abstract)
or (ObjectDoesNotExist,), module))
new_class.add_to_class('MultipleObjectsReturned', subclass_exception('MultipleObjectsReturned',
tuple(x.MultipleObjectsReturned
for x in parents if hasattr(x, '_meta') and not x._meta.abstract)
or (MultipleObjectsReturned,), module))
if base_meta:
if not base_meta.abstract:
# Non-abstract child classes inherit some attributes from their
# non-abstract parent (unless an ABC comes before it in the
# method resolution order).
if not hasattr(meta, 'ordering'):
new_class._meta.ordering = base_meta.ordering
if not hasattr(meta, 'get_latest_by'):
new_class._meta.get_latest_by = base_meta.get_latest_by
if base_meta.materialized_view or base_meta.leaf or (
base_meta.db_view and base_meta.intermediate):
if mat_view :
raise TypeError('A materialized view cannot inherit from another')
new_class._meta.leaf = True
leaf = True
# register the materialized_view base
new_class._meta.mat_view_base = base_meta.concrete_model
if base_meta.leaf:
mat_view_base = base_meta.mat_view_base
new_class._meta.mat_view_base = mat_view_base
# turn the base into an intermediate view
base_meta.db_view = True
if base_meta._auto_db_table:
base_meta.db_table = '%s_%s' % (base_meta.db_table, 'view')
base_meta.intermediate = True
base_meta.leaf = False
base_meta.abstract = True
if base_meta.concrete:
base_model = mat_view_base._meta.leaf_ids[base_meta.leaf_id]
# concrete views know about themselves...
base_meta.leaves = {base_model: base_meta.leaf_id}
base_meta.leaf_ids = {base_meta.leaf_id: base_model}
else:
base_meta.leaves = {}
base_meta.leaf_ids = {}
ctype_field = IntegerField(db_index=True)
ctype_field.acquired = True
base_meta.concrete_model.add_to_class('pgd_child_type', ctype_field)
if base_meta.intermediate:
new_class._meta.mat_view_base = base_meta.mat_view_base
is_proxy = new_class._meta.proxy
if getattr(new_class, '_default_manager', None):
if not is_proxy:
# Multi-table inheritance doesn't inherit default manager from
# parents.
new_class._default_manager = None
new_class._base_manager = None
else:
# Proxy classes do inherit parent's default manager, if none is
# set explicitly.
new_class._default_manager = new_class._default_manager._copy_to_model(new_class)
new_class._base_manager = new_class._base_manager._copy_to_model(new_class)
# Bail out early if we have already created this class.
m = get_model(new_class._meta.app_label, name,
seed_cache=False, only_installed=False)
if m is not None:
return m
# Add all attributes to the class.
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj)
if mat_view:
# add a pgd_child_type field to identify the model of each view row
if 'pgd_child_type' in attrs:
# pfff... bloody clever users... It's 2:06 AM now, I won't fix it
pass
ctype_field = IntegerField(db_index=True)
ctype_field.acquired = True
new_class.add_to_class('pgd_child_type', ctype_field)
# add caches of the children
new_class._meta.leaf_ids = {}
new_class._meta.leaves = {}
# All the fields of any type declared on this model
new_fields = new_class._meta.local_fields + \
new_class._meta.local_many_to_many + \
new_class._meta.virtual_fields
field_names = set([f.name for f in new_fields])
# Basic setup for proxy models.
if is_proxy:
base = None
for parent in [cls for cls in parents if hasattr(cls, '_meta')]:
if parent._meta.abstract:
if parent._meta.fields:
raise TypeError("Abstract base class containing model fields not permitted for proxy model '%s'." % name)
else:
continue
if base is not None:
raise TypeError("Proxy model '%s' has more than one non-abstract model base class." % name)
else:
base = parent
if base is None:
raise TypeError("Proxy model '%s' has no non-abstract model base class." % name)
if (new_class._meta.local_fields or
new_class._meta.local_many_to_many):
raise FieldError("Proxy model '%s' contains model fields." % name)
new_class._meta.setup_proxy(base)
new_class._meta.concrete_model = base._meta.concrete_model
else:
new_class._meta.concrete_model = new_class
# Do the appropriate setup for any model parents.
o2o_map = dict([(f.rel.to, f) for f in new_class._meta.local_fields
if isinstance(f, OneToOneField)])
if leaf:
# Add all child fields on its materalized and intermediate views and mark them
# acquired
child_fields = new_class._meta.local_fields + new_class._meta.local_many_to_many
for base in [c for c in new_class.__mro__ if hasattr(c, '_meta') and (
c._meta.intermediate or c._meta.materialized_view) ]:
inserted = False
for field in child_fields:
if not getattr(field, 'acquired', False):
inserted = True
parent_field = copy.deepcopy(field)
parent_field.acquired = True
if base._meta.intermediate:
parent_field.child_field = True
base.add_to_class(field.name, parent_field)
if inserted:
# move pgd_child_type at last position on the parent
ctype_field = base._meta.get_field_by_name('pgd_child_type')[0]
base._meta.local_fields.remove(ctype_field)
base._meta.local_fields.append(ctype_field)
# invalidate field caches
if hasattr(base._meta, '_field_cache'):
del base._meta._field_cache
del base._meta._field_name_cache
if hasattr(base._meta, '_name_map'):
del base._meta._name_map
for base in parents:
original_base = base
if not hasattr(base, '_meta'):
# Things without _meta aren't functional models, so they're
# uninteresting parents.
continue
parent_fields = base._meta.local_fields + base._meta.local_many_to_many
# Check for clashes between locally declared fields and those
# on the base classes (we cannot handle shadowed fields at the
# moment, except in mat. view inheritance).
if not leaf:
for field in parent_fields:
if field.name in field_names:
raise FieldError('Local field %r in class %r clashes '
'with field of similar name from '
'base class %r' %
(field.name, name, base.__name__))
if not base._meta.abstract:
# Concrete classes...
base = base._meta.concrete_model
if base in o2o_map:
field = o2o_map[base]
elif not is_proxy:
attr_name = '%s_ptr' % base._meta.module_name
field = OneToOneField(base, name=attr_name,
auto_created=True, parent_link=True)
new_class.add_to_class(attr_name, field)
else:
field = None
new_class._meta.parents[base] = field
else:
# .. and abstract ones.
for field in parent_fields:
if not getattr(field, 'acquired', False):
new_class.add_to_class(field.name, copy.deepcopy(field))
# Pass any non-abstract parent classes onto child.
new_class._meta.parents.update(base._meta.parents)
# Inherit managers from the abstract base classes.
new_class.copy_managers(base._meta.abstract_managers)
# Proxy models inherit the non-abstract managers from their base,
# unless they have redefined any of them.
if is_proxy:
new_class.copy_managers(original_base._meta.concrete_managers)
# Inherit virtual fields (like GenericForeignKey) from the parent
# class
for field in base._meta.virtual_fields:
if base._meta.abstract and field.name in field_names:
raise FieldError('Local field %r in class %r clashes '\
'with field of similar name from '\
'abstract base class %r' % \
(field.name, name, base.__name__))
new_class.add_to_class(field.name, copy.deepcopy(field))
if abstract:
# Abstract base models can't be instantiated and don't appear in
# the list of models for an app. We do the final setup for them a
# little differently from normal models.
attr_meta.abstract = False
new_class.Meta = attr_meta
return new_class
new_class._prepare()
if mat_view:
# now we know the table name, we can set the sequence name
tname = new_class._meta.db_table
new_class._meta.pk.sequence = tname + '_id_seq'
register_models(new_class._meta.app_label, new_class)
# Because of the way imports happen (recursively), we may or may not be
# the first time this model tries to register with the framework. There
# should only be one class for each model, so we always return the
# registered version.
new_class = get_model(new_class._meta.app_label, name,
seed_cache=False, only_installed=False)
if mat_view:
# turn it into an abstract model, so children won't try to create
# joins
new_class._meta.abstract = True
# Now, we override new_class.__new__ on non-concrete intermediate and
# materialized views to choose the class of the new object returned
# when the user (or a QuerySet) tries to instantiate it.
# It is chosen amongst leaves
def new_matview_new(klass,*args,**kwargs):
# leaf classes are not patched
if not (klass._meta.materialized_view or
klass._meta.intermediate):
return Model.__new__(klass, *args, **kwargs)
if len(kwargs) and klass._meta.concrete:
# probably a user instanciation
return Model.__new__(klass, *args, **kwargs)
parent_fnames = [f.column for f in klass._meta.fields]
idx = parent_fnames.index('pgd_child_type')
if len(args) <= idx and 'pgd_child_type' not in kwargs:
# I wouldn't do that if I were you. Seems like a smart (or
# crazy) user is trying to do something clever (or foolish)
# and I don't want to refrain one's creativity. This model
# cannot be saved anyway.
return Model.__new__(klass,*args,**kwargs)
# Here is the magic: if you try to instanciate a m10d view
# you get its subbclass corresponding to its pgd_child_type
# That how mixed queryset work.
# pgd_child_type should be the last field. Just to be sure
leaf = klass._meta.leaf_ids.get(args[idx],None)
# TODO PG: add an exception here if None
# hook the __init__ arguments
leaf_fnames = [f.name for f in leaf._meta.fields]
leaf_args = [None]*len(leaf_fnames)
for i in range(len(parent_fnames)):
fname = parent_fnames[i]
if fname in leaf_fnames:
leaf_args[leaf_fnames.index(fname)] = args[i]
inst = Model.__new__(leaf,*leaf_args,**kwargs)
# The modified arg list is stored on the instance itself.
# A hook in __init__ will send it to the original __init__
inst.__hooked_args__ = leaf_args
return inst
new_matview_new.__patched__ = True
if not getattr(new_class.__new__, '__patched__', False):
new_class.__new__ = staticmethod(new_matview_new)
if leaf or (new_class._meta.intermediate and new_class._meta.concrete):
# register the leaf on its materialized_view base model
mvbase = new_class._meta.mat_view_base
mvbase._meta.register_leaf(new_class)
return new_class
class IntegerFieldFloatRounding(object):
"""
Allow floats to work as query values for IntegerField. Without this, the
decimal portion of the float would always be discarded.
"""
def get_prep_lookup(self):
if isinstance(self.rhs, float):
self.rhs = math.ceil(self.rhs)
return super(IntegerFieldFloatRounding, self).get_prep_lookup()
class IntegerGreaterThanOrEqual(IntegerFieldFloatRounding, GreaterThanOrEqual):
pass
IntegerField.register_lookup(IntegerGreaterThanOrEqual)
class IntegerLessThan(IntegerFieldFloatRounding, LessThan):
pass
IntegerField.register_lookup(IntegerLessThan)
class In(FieldGetDbPrepValueIterableMixin, BuiltinLookup):
lookup_name = 'in'
def process_rhs(self, compiler, connection):
db_rhs = getattr(self.rhs, '_db', None)
if db_rhs is not None and db_rhs != connection.alias:
raise ValueError(
"Subqueries aren't allowed across different databases. Force "
def __init__(self, with_respect_to=[], **kwargs):
self.with_respect_to = with_respect_to
kwargs['null'] = False
kwargs['editable'] = False
IntegerField.__init__(self, **kwargs )
