class Exam(models.Model):
"""模拟考试"""
customer = models.ForeignKey('customers.Customer',
on_delete=models.CASCADE,
verbose_name='考试人')
subject = models.ForeignKey('subjects.Subject',
on_delete=models.DO_NOTHING,
verbose_name='所属科目',
null=True,
blank=True)
questions = JSONField(default='[]', verbose_name='题目列表')
# [id1, id2,]
answer = JSONField(default='[]', verbose_name='答案列表')
# [{"id": qid, "answer": [], "is_correct": True},]
result = JSONField(default='{}', verbose_name='考试结果')
# {"correct_count": 20, "wrong_cout": 10, "blank_count": 0, "score": 100}
update_at = models.DateTimeField(auto_now=True, verbose_name='更新时间')
create_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
objects = ExamManager()
class Meta:
db_table = DB_PREFIX + 'exams'
ordering = ['-id']
def get_question_list(self):
"""获取题目详情
"""
questions = []
for q in self.questions:
questions.append(mm_Question.get_question(q))
return questions
class VersionPreview(BasePreview, ModelBase):
version = models.ForeignKey(Version,
related_name='previews',
on_delete=models.CASCADE)
position = models.IntegerField(default=0)
sizes = JSONField(default={})
colors = JSONField(default=None, null=True)
media_folder = 'version-previews'
class Meta:
db_table = 'version_previews'
ordering = ('position', 'created')
indexes = [
LongNameIndex(fields=('version', ),
name='version_previews_version_id_fk_versions_id'),
models.Index(fields=('version', 'position', 'created'),
name='version_position_created_idx'),
]
@cached_property
def caption(self):
"""We only don't support defining a caption for previews because
they're auto-generated. This is for compatibility with Addon Preview
objects. (it's a cached_property so it can be set transparently)"""
return None
class WebsiteSubmission(ModelBase):
"""
Model representing a website submission.
When approved, the data from this will be copied to a new instance of the
Website model, and approved=True will be set on the submission instance.
"""
name = TranslatedField()
keywords = JSONField(default=None)
description = TranslatedField()
categories = JSONField(default=None)
date_approved = models.DateTimeField(blank=True, null=True)
# `detected_icon` is the URL of the icon we are able to gather from the
# submitted site's metadata. In the reviewer tools, reviewers will be able
# to accept that icon, or upload one of their own.
detected_icon = models.URLField(max_length=255, blank=True)
icon_type = models.CharField(max_length=25, blank=True, null=True)
icon_hash = models.CharField(max_length=8, blank=True, null=True)
# The `url` field is the URL as entered by the submitter. The
# `canonical_url` field is the URL that the site reports as the canonical
# location for the submitted URL. In the reviewer tools, reviewers will
# have the ability to copy the `canonical_url` value to the `url` field.
url = models.URLField(max_length=255)
canonical_url = models.URLField(max_length=255, blank=True, null=True)
# A 1-5 Likert scale indicating how well the submitter says the website
# works. This is primarily used to make the submitter question the
# relevance of their submission, though submissions should be prevented if
# the user says it works poorly.
works_well = IntegerRangeField(min_value=2, max_value=5)
# Who is submitting the website? Do they want public credit for their
# submission?
submitter = models.ForeignKey(UserProfile,
blank=True,
null=True,
related_name='websites_submitted')
public_credit = models.BooleanField(default=False)
# Why does the user think the website is relevant to Marketplace?
why_relevant = models.TextField()
# If the submitter says the website is relevant worldwide,
# preferred_regions should be set to [].
preferred_regions = JSONField(default=None, blank=True, null=True)
# Turn true when a reviewer has approved and published a submission.
approved = models.BooleanField(default=False, db_index=True)
objects = WebsiteSubmissionManager()
class Meta:
ordering = (('-modified'), )
def __unicode__(self):
return unicode(self.url)
class Frame(TimeStampedModel):
node = models.ForeignKey(Node)
text = models.TextField()
annotations = JSONField(null=True, blank=True)
key_entities = JSONField(null=True, blank=True)
def __unicode__(self):
return self.text
class Result(TimeStampedModel):
STATUS = Choices((0, 'unknown', _('Unknown')),
(1, 'ok', _('OK')),
(2, 'warning', _('Warning')),
(3, 'critical', _('Critical')))
slug = models.TextField(verbose_name=_('Module slug'))
identifier = models.CharField(max_length=256, verbose_name=_('Identifier'))
status = models.IntegerField(choices=STATUS,
default=STATUS.unknown, verbose_name=_('Status'))
data = JSONField(blank=True, default=dict, verbose_name=('Data'))
config = JSONField(blank=True, default=dict, verbose_name=_('Configuration'))
payload_description = models.TextField(verbose_name=_('Payload description'))
acknowledged_by = models.ForeignKey(to=settings.AUTH_USER_MODEL, null=True, blank=True,
verbose_name=_('Acknowledged by'),
related_name='acknowledged_by')
acknowledged_at = models.DateTimeField(null=True, blank=True, verbose_name=_('Acknowledged at'))
acknowledged_until = models.DateTimeField(null=True, blank=True, verbose_name=_('Acknowledged until'))
acknowledged_reason = models.TextField(blank=True, verbose_name=_('Acknowledge reason'))
assigned_to_user = models.ForeignKey(to=settings.AUTH_USER_MODEL, null=True, blank=True,
related_name='assigned_to_user')
assigned_to_group = models.ForeignKey(to='auth.Group', null=True, blank=True)
objects = ResultQuerySet.as_manager()
class Meta:
unique_together = ('slug', 'identifier')
permissions = (('view', 'Can view results dashboard and details'), ('acknowledge', 'Can acknowledge results'),
('config', 'Can change the configuration for results'), ('refresh', 'Can refresh results'))
def acknowledge(self, user, days, reason=None, commit=True):
if self.status in (self.STATUS.warning, self.STATUS.critical) and self.is_acknowledged():
raise AlreadyAcknowledged()
self.acknowledged_at = timezone.now()
self.acknowledged_by = user
self.acknowledged_until = timezone.now() + relativedelta.relativedelta(days=days)
self.acknowledged_reason = reason or ''
if commit:
self.save(update_fields=['acknowledged_at', 'acknowledged_by', 'acknowledged_until', 'acknowledged_reason'])
def is_acknowledged(self):
return self.acknowledged_until and self.acknowledged_until >= timezone.now()
def __str__(self):
return self.slug
def get_check_instance(self):
return datawatch.get_check_class(self.slug)()
def get_payload(self):
return self.get_check_instance().get_payload(self.identifier)
def get_formatted_data(self):
return datawatch.get_check_class(self.slug)().format_result_data(self)
class Question(models.Model):
AggregationChoices = (
('sum', 'Sum'),
('average', 'Average'),
('winner', 'Winner'),
)
survey = models.ForeignKey('surveys.Survey')
remote_id = models.CharField(max_length=200, blank=True, null=True)
type = models.CharField(max_length=200, blank=True, null=True)
title = models.CharField(max_length=500, blank=True, null=True)
display = models.BooleanField(default=True)
display_theme = models.CharField(max_length=50, blank=True, null=True)
display_title = models.CharField(max_length=500, blank=True, null=True)
display_style = models.CharField(max_length=500, blank=True, null=True)
left_label = models.CharField(max_length=200, blank=True, null=True)
right_label = models.CharField(max_length=200, blank=True, null=True)
aggregation = models.CharField(max_length=200, choices=AggregationChoices, null=True, blank=True)
properties = JSONField(null=True)
specification = JSONField(null=True)
def save(self, *args, **kwargs):
if not self.id:
self.display_title = self.title
try:
self.left_label = self.properties['left_label']
except KeyError:
pass
try:
self.right_label = self.properties['right_label']
except KeyError:
pass
return super(Question, self).save(*args, **kwargs)
def get_platform_aggregate(self, start=None, end=None):
answers = self.aggregateanswer_set.filter(aggregation_type='combined').all()
if start:
answers = answers.filter(project__campaign_ended__gte=start)
if end:
answers = answers.filter(project__campaign_ended__lte=end)
if self.type in ('number', 'slider', 'percent'):
if (self.aggregation == 'average'):
return answers.aggregate(value=models.Avg('value'))['value']
else:
return answers.aggregate(value=models.Sum('value'))['value']
elif self.type in ('radio', 'checkbox', 'table-radio'):
values = defaultdict(list)
for answer in answers:
[values[key].append(value) for key, value in answer.options.items()]
return dict((key, float(sum(value)) / len(value)) for key, value in values.items())
def __unicode__(self):
return bleach.clean(unicode(self.title), strip=True, tags=[])
class Question(models.Model):
"""题目"""
subject = models.ForeignKey('subjects.Subject',
on_delete=models.SET_NULL,
blank=True,
null=True,
verbose_name='科目')
qtype = models.PositiveSmallIntegerField(
choices=ModelManager.Question_Type,
default=ModelManager.Question_Type_Danxuanti,
verbose_name='题型')
content = models.TextField(verbose_name='题目内容')
choices = JSONField(default='[]', verbose_name='选项列表')
# [{"label": "A", "content": "选项内容"}, {"label": "A", "content": "选项内容"},]
images = JSONField(default='[]', verbose_name='图片列表')
# [{"url": "https:xxx.jpg", "name": "图1"}]
answer = JSONField(default='[]', verbose_name='正确答案')
update_at = models.DateTimeField(auto_now=True, verbose_name='更新时间')
create_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
markers = models.ManyToManyField('customers.Customer', verbose_name='收藏人')
objects = QuestionManager()
class Meta:
db_table = DB_PREFIX + 'questions'
ordering = ['-id']
verbose_name = verbose_name_plural = '题目管理'
def __str__(self):
return '<{qid}: {content}>'.format(qid=self.id,
content=self.content[:10])
def is_correct_answer(self, answer_list):
"""判断答案对错"""
upper_correct_answer = [choice.upper() for choice in list(self.answer)]
upper_answer_list = [choice.upper() for choice in answer_list]
if len(upper_correct_answer) != len(upper_answer_list):
return ModelManager.Answer_Result_Wrong
for item in upper_correct_answer:
if item not in upper_answer_list:
return ModelManager.Answer_Result_Wrong
return ModelManager.Answer_Result_Correct
@property
def dict(self):
data = {
'id': self.id,
'subject_id': self.subject_id,
'qtype': self.qtype,
'content': self.content,
'choices': self.choices,
'images': self.images,
'answer': self.answer,
'update_at': strtime(self.update_at),
'create_at': strtime(self.create_at)
}
return data
class WxGroup(models.Model):
"""[summary]
- groupinfo(群信息结构):
{
"head_img": "http://wx.qlogo.cn/mmcrhead/uchmtWQh7iaqDiboEJT29lP9avibibicrDibuY5BDoI11mdwNd9GfrmTgsfib81K6bzu8wvoYKllShC0FK189Pfruymwib05m0FPkJeic/0",
"member_count": 4,
"member_nickname_list": [
"Cvmars",
"碗底有虫",
"Zdz",
"yu"
],
"member_wxid_list": [
"hehaifeng4235",
"wxid_96r2lcupwp6f21",
"wxid_smrapzzeruvp21",
"wxid_r1nrc1u1m4qw22"
],
"name": "先退的是狗",
"owner_wxid": "hehaifeng4235",
"room_wxid": "5609987290@chatroom",
"wxid": "5609987290@chatroom"
}
"""
head_img = models.CharField(max_length=200,
blank=True,
null=True,
verbose_name='头像的url地址')
member_count = models.PositiveIntegerField(default=0,
verbose_name='该群成员总数')
member_nickname_list = JSONField(default='[]', verbose_name='成员昵称列表')
member_wxid_list = JSONField(default='[]', verbose_name='当前群的成员wxid的列表')
name = models.CharField(max_length=200,
blank=True,
null=True,
verbose_name='群名称')
owner_wxid = models.CharField(max_length=200,
blank=True,
null=True,
verbose_name='群主wxid')
room_wxid = models.CharField(max_length=200,
db_index=True,
blank=True,
null=True,
verbose_name='群wxid')
# wxid = models.CharField(max_length=200, verbose_name='wxid')
bot_wxid = models.CharField(max_length=200,
blank=True,
null=True,
verbose_name='bot_wxid')
memberInfo_list = JSONField(default='[]', verbose_name='当前群的成员信息列表')
objects = WxGroupManager()
class Meta:
db_table = 'wx_group'
unique_together = [['room_wxid', 'bot_wxid']]
class Event(models.Model):
"""
{
"address": "0x25Ff5dc79A7c4e34254ff0f4a19d69E491201DD3",
"blockNumber": 3,
"transactionHash": "0xc18a24a35052a5a3375ee6c2c5ddd6b0587cfa950b59468b67f63f284e2cc382",
"transactionIndex": 0,
"blockHash": "0x62469a8d113b27180c139d88a25f0348bb4939600011d33382b98e10842c85d9",
"logIndex": 0,
"removed": false,
"id": "log_25652065",
"returnValues": {
"0": "0xFCaf25bF38E7C86612a25ff18CB8e09aB07c9885",
"shipTokenContractAddress": "0xFCaf25bF38E7C86612a25ff18CB8e09aB07c9885"
},
"event": "SetTokenContractAddressEvent",
"signature": "0xbbbf32f08c8c0621e580dcf0a8e0024525ec357db61bb4faa1a639d4f958a824",
"raw": {
"data": "0x000000000000000000000000fcaf25bf38e7c86612a25ff18cb8e09ab07c9885",
"topics": [
"0xbbbf32f08c8c0621e580dcf0a8e0024525ec357db61bb4faa1a639d4f958a824"
]
}
}
"""
id = models.CharField(primary_key=True, default=random_id, max_length=36)
eth_action = models.ForeignKey(EthAction,
on_delete=models.CASCADE,
blank=True,
null=True)
created_at = models.DateTimeField(auto_now_add=True)
address = AddressField()
block_number = models.BigIntegerField()
transaction_hash = HashField()
transaction_index = models.IntegerField()
block_hash = HashField()
log_index = models.IntegerField()
removed = models.BooleanField()
event_id = models.CharField(max_length=514)
return_values = JSONField()
event_name = models.CharField(max_length=514)
signature = HashField()
raw = JSONField()
class Meta:
constraints = [
models.UniqueConstraint(fields=['eth_action', 'log_index'],
name='unique event')
]
@staticmethod
def get_event_subscription_url():
return settings.INTERNAL_URL + reverse('event-list',
kwargs={'version': 'v1'})
class WebextPermission(ModelBase):
NATIVE_MESSAGING_NAME = u'nativeMessaging'
permissions = JSONField(default={})
optional_permissions = JSONField(default={})
file = models.OneToOneField('File',
related_name='_webext_permissions',
on_delete=models.CASCADE)
class Meta:
db_table = 'webext_permissions'
class BlogPost(models.Model):
wp_id = models.IntegerField()
wp_blog_slug = models.CharField(max_length=50)
date = models.DateTimeField()
modified = models.DateTimeField()
title = models.CharField(max_length=255)
excerpt = models.TextField()
link = models.URLField()
featured_media = JSONField()
tags = JSONField()
objects = BlogPostManager()
class Meta:
get_latest_by = 'date'
ordering = ['-date']
def __str__(self):
return '%s: %s' % (self.blog_name, self.title)
def get_absolute_url(self):
return self.link
def htmlify(self):
return Markup(self.excerpt)
@property
def blog_title(self):
return Markup(self.title).unescape()
@property
def blog_link(self):
return settings.WP_BLOGS[self.wp_blog_slug]['url']
@property
def blog_name(self):
return settings.WP_BLOGS[self.wp_blog_slug]['name']
def get_featured_tag(self, tags):
"""Return a tag present both in the post and the passed in list.
If no tag matches something odd has happened, so just return blank.
"""
matching_tags = list(set(self.tags) & set(tags))
if matching_tags:
return random.choice(matching_tags)
else:
return ''
def get_featured_image_url(self, size='large'):
try:
return self.featured_media['media_details']['sizes'][size][
'source_url']
except (KeyError, TypeError):
return None
class Race(models.Model):
name = models.CharField(max_length=255)
horses = models.ManyToManyField(Horse, related_name='races', blank=True)
paddy_power_data = JSONField(blank=True, help_text='"url" and "event_id" is required')
bet365_data = JSONField(blank=True)
william_hill_data = JSONField(blank=True, help_text='"url" and "template_name" is required')
sky_bet_data = JSONField(blank=True, help_text='"url" and "event_id" is required')
def __str__(self):
return self.name
def test_get_prep_value(self):
j_field = JSONField()
self.assertEqual(
six.u(dumps([{'a': 'a'}])),
j_field.get_prep_value(value=[{'a': 'a'}])
)
self.assertEqual(
six.u(dumps([{'a': 'a'}])),
j_field.get_prep_value(value='[{"a": "a"}]')
)
def test_get_prep_value(self):
j_field = JSONField()
self.assertEqual(six.u(dumps([{
'a': 'a'
}])), j_field.get_prep_value(value=[{
'a': 'a'
}]))
self.assertEqual(six.u(dumps([{
'a': 'a'
}])), j_field.get_prep_value(value='[{"a": "a"}]'))
def test_get_db_prep_save(self):
j_field = JSONField()
self.assertEqual(
six.u(dumps([{'a': 'a'}])),
j_field.get_db_prep_save(value=[{'a': 'a'}], connection=None)
)
self.assertEqual(
six.u('[{"a": "a"}]'),
j_field.get_db_prep_save(value='[{"a": "a"}]', connection=None)
)
class HistoricalFeatureRecords(HistoricalRecords):
additional_fields = {
'references': JSONField(default=[]),
'children': JSONField(default=[])
}
def get_references_value(self, instance, mtype):
return list(
instance.references.values_list('pk', flat=True))
def get_children_value(self, instance, mtype):
return list(
instance.get_children().values_list('pk', flat=True))
class Explorer(models.Model):
coin = models.ForeignKey(Coin, on_delete=models.CASCADE, related_name='explorer')
updated = models.DateTimeField(default=timezone.now)
last_block = models.DateTimeField(default=timezone.now)
circulating = models.CharField(max_length=124, default='0')
height = models.CharField(max_length=124, default='0')
reward = models.CharField(max_length=124, default='0')
average_blocktime = models.CharField(max_length=124, default='0')
totalcoins = models.CharField(max_length=124, default='0')
target_diff = JSONField(default={})
total_diff = JSONField(default={})
to_save = models.BooleanField(default=False)
class Project(Model):
class Meta:
verbose_name = verbose_name_plural = '团作项目'
GRADE_BEGINNER = 1
GRADE_INTERMEDIATE = 2
GRADE_ADVANCED = 3
GRADE_CHOICES = (
(GRADE_BEGINNER, '初级'),
(GRADE_INTERMEDIATE, '中级'),
(GRADE_BEGINNER, '高级'),
)
name = models.CharField('名称', max_length=64, blank=True, default='')
logo = models.URLField('Logo', blank=True, default='')
simple_description = models.CharField('简介',
blank=True,
max_length=256,
default='')
grade = models.SmallIntegerField('难度',
choices=GRADE_CHOICES,
default=GRADE_BEGINNER)
video_tutorial = models.BooleanField('有视频讲解', default=False)
text_tutorial = models.BooleanField('有图文教程', default=False)
start = models.DateTimeField('开始日期', default=timezone.now)
end = models.DateTimeField('结束日期', default=timezone.now)
images = JSONField('图片列表', blank=True, default=[])
detail_images = JSONField('详情图片列表', blank=True, default=[])
description = models.TextField('详细描述', blank=True, default='')
created_by = models.ForeignKey(AUTH_USER_MODEL,
models.SET_NULL,
verbose_name='创建人',
blank=True,
null=True,
default=None)
created_at = models.DateTimeField('加入时间', default=timezone.now)
swiper = models.BooleanField('首页轮播展示', default=False)
recommend = models.BooleanField('首页推荐展示', default=False)
skills = models.ManyToManyField(Skill)
def __str__(self):
return self.name
class UpdateCount(StatsSearchMixin, models.Model):
# Has an index `addon_id` in our dev, stage and prod database
addon = models.ForeignKey('addons.Addon')
# Has an index named `count` in our dev, stage and prod database
count = models.PositiveIntegerField(db_index=True)
# Has an index named `date` in our dev, stage and prod database
date = models.DateField(db_index=True)
versions = JSONField(db_column='version', null=True)
statuses = JSONField(db_column='status', null=True)
applications = JSONField(db_column='application', null=True)
oses = JSONField(db_column='os', null=True)
locales = JSONField(db_column='locale', null=True)
class Meta:
db_table = 'update_counts'
class Answer(models.Model):
response = models.ForeignKey('surveys.Response')
question = models.ForeignKey('surveys.Question')
remote_id = models.CharField(max_length=200, blank=True, null=True)
specification = JSONField(null=True)
value = models.CharField(max_length=5000, blank=True)
options = JSONField(null=True)
@property
def float_value(self):
try:
return float(self.value.replace('%', ''))
except ValueError:
return 0
class BlogPost(models.Model):
wp_id = models.IntegerField()
wp_blog_slug = models.CharField(max_length=50)
date = models.DateTimeField()
modified = models.DateTimeField()
title = models.CharField(max_length=255)
excerpt = models.TextField()
link = models.URLField()
featured_media = JSONField()
tags = JSONField()
objects = BlogPostManager()
class Meta:
get_latest_by = 'date'
ordering = ['-date']
def __unicode__(self):
return '%s: %s' % (self.blog_name, self.title)
def get_absolute_url(self):
return self.link
def htmlify(self):
summary = strip_tags(self.excerpt).strip()
if summary.lower().endswith('continue reading'):
summary = summary[:-16]
return Markup(summary)
@property
def blog_title(self):
title = strip_tags(self.title).strip()
return Markup(title).unescape()
@property
def blog_link(self):
return settings.WP_BLOGS[self.wp_blog_slug]['url']
@property
def blog_name(self):
return settings.WP_BLOGS[self.wp_blog_slug]['name']
def get_featured_image_url(self, size='large'):
try:
return self.featured_media['media_details']['sizes'][size]['source_url']
except KeyError:
return None
class SecurityAdvisory(models.Model):
id = models.CharField(max_length=8, primary_key=True, db_index=True)
title = models.CharField(max_length=200)
impact = models.CharField(max_length=100)
reporter = models.CharField(max_length=100, null=True)
announced = models.DateField(null=True)
year = models.SmallIntegerField()
order = models.SmallIntegerField()
fixed_in = models.ManyToManyField(Product, related_name='advisories')
extra_data = JSONField()
html = models.TextField()
last_modified = ModificationDateTimeField()
class Meta:
ordering = ('-year', '-order')
get_latest_by = 'last_modified'
def __unicode__(self):
return u'MFSA {0}'.format(self.id)
def get_absolute_url(self):
return reverse('security.advisory', kwargs={'pk': self.id})
@property
def impact_class(self):
return self.impact.lower().split(None, 1)[0]
@property
def products(self):
prods_set = set(v.product for v in self.fixed_in.all())
return sorted(prods_set)
class Container(BaseResource):
history = HistoricalRecords()
cpu = models.IntegerField()
mem = models.IntegerField()
replicas = models.IntegerField(default=3)
k8s_cluster = models.ForeignKey(K8sCluster, on_delete=models.PROTECT)
extra_args = JSONField(default={})
class LabTest(models.Model):
# Fields
created = models.DateTimeField(auto_now_add=True, editable=False)
last_updated = models.DateTimeField(auto_now=True, editable=False)
metadata = JSONField(default=dict, null=True, blank=True)
is_approved = models.BooleanField(default=True)
name = models.CharField(max_length=120, unique=True)
slug = extension_fields.AutoSlugField(populate_from='name', blank=True)
aliases = ArrayField(models.CharField(max_length=1024),
blank=True,
null=True,
default=list)
description = models.TextField(max_length=4096, blank=True, null=True)
purpose = models.TextField(max_length=2048, blank=True, null=True)
indication = models.TextField(max_length=2048, blank=True, null=True)
sample = models.TextField(max_length=2048, blank=True, null=True)
preparation = models.TextField(max_length=2048, blank=True, null=True)
usage = models.TextField(max_length=4096, blank=True, null=True)
interpretation = models.TextField(max_length=4096, blank=True, null=True)
notes = models.TextField(max_length=4096, blank=True, null=True)
objects = LabTestManager()
class Meta:
ordering = ('name', )
def __str__(self):
return self.name
class StripeBasicModel(models.Model):
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
stripe_response = JSONField(blank=True)
class Meta:
abstract = True
class PatientDiagnosis(models.Model):
# Fields
created = models.DateTimeField(auto_now_add=True, editable=False)
last_updated = models.DateTimeField(auto_now=True, editable=False)
metadata = JSONField(default=dict, null=True, blank=True)
is_deleted = models.BooleanField(default=False)
# Relationship Fields
diagnosis = models.ForeignKey(Diagnosis,
related_name="patient_diagnoses",
on_delete=models.CASCADE,
null=True)
checkup = models.ForeignKey(PatientCheckupRecord,
related_name="checkup_diagnoses",
on_delete=models.CASCADE,
null=True)
added_by = models.ForeignKey('doctor_profiles.DoctorProfile',
on_delete=models.SET_NULL,
null=True,
related_name='diagnoses_added')
removed_by = models.ForeignKey('doctor_profiles.DoctorProfile',
on_delete=models.SET_NULL,
null=True,
related_name='diagnoses_deleted')
objects = PatientDiagnosisManager()
class Meta:
ordering = ('diagnosis__name', )
unique_together = ('diagnosis', 'checkup')
def __str__(self):
return f'{self.diagnosis}'
class CheckupNote(models.Model):
# Fields
created = models.DateTimeField(auto_now_add=True, editable=False)
last_updated = models.DateTimeField(auto_now=True, editable=False)
metadata = JSONField(default=dict, null=True, blank=True)
note = models.TextField(max_length=1024)
# Relationship Fields
checkup = models.ForeignKey(PatientCheckupRecord,
related_name="checkup_notes",
on_delete=models.CASCADE,
null=True)
added_by = models.ForeignKey('doctor_profiles.DoctorProfile',
on_delete=models.SET_NULL,
null=True,
related_name='notes_added')
objects = CheckupNoteManager()
class Meta:
ordering = ('checkup', )
def __str__(self):
return f'{self.checkup}: {self.note[:30]}'
class PatientSymptom(models.Model):
# Fields
created = models.DateTimeField(auto_now_add=True, editable=False)
last_updated = models.DateTimeField(auto_now=True, editable=False)
metadata = JSONField(default=dict, null=True, blank=True)
is_deleted = models.BooleanField(default=False)
# Relationship Fields
symptom = models.ForeignKey(Symptom,
related_name="patient_symptoms",
on_delete=models.CASCADE,
null=True)
checkup = models.ForeignKey(PatientCheckupRecord,
related_name="checkup_symptoms",
on_delete=models.CASCADE,
null=True)
added_by = models.ForeignKey('doctor_profiles.DoctorProfile',
on_delete=models.SET_NULL,
null=True,
related_name='symptoms_added')
removed_by = models.ForeignKey('doctor_profiles.DoctorProfile',
on_delete=models.SET_NULL,
null=True,
related_name='symptoms_deleted')
objects = PatientSymptomManager()
class Meta:
ordering = ('symptom__name', )
unique_together = ('symptom', 'checkup')
def __str__(self):
return f'{self.symptom}: {self.checkup.appointment.patient}'
class PatientLabTestRequest(models.Model):
# Fields
created = models.DateTimeField(auto_now_add=True, editable=False)
last_updated = models.DateTimeField(auto_now=True, editable=False)
metadata = JSONField(default=dict, null=True, blank=True)
is_approved = models.BooleanField(default=True)
# Relationship Fields
lab_test = models.ForeignKey(LabTest,
on_delete=models.CASCADE,
related_name='tested_patients')
checkup = models.ForeignKey('doctor_profiles.PatientCheckupRecord',
on_delete=models.CASCADE,
related_name='checkup_tests')
requested_by = models.ForeignKey('doctor_profiles.DoctorProfile',
on_delete=models.SET_NULL,
null=True,
related_name='labtests_requested')
removed_by = models.ForeignKey('doctor_profiles.DoctorProfile',
on_delete=models.SET_NULL,
null=True,
related_name='labtests_dismissed')
objects = PatientLabTestRequestManager()
class Meta:
ordering = ('checkup', )
unique_together = ('lab_test', 'checkup')
def __str__(self):
return f'{self.lab_test}: {self.checkup}'
class BadgeAssertion(models.Model):
"""
Tracks badges on our side of the badge baking transaction
"""
user = models.ForeignKey(User)
course_id = CourseKeyField(max_length=255, blank=True, default=None)
# Mode a badge was awarded for.
mode = models.CharField(max_length=100)
data = JSONField()
@property
def image_url(self):
"""
Get the image for this assertion.
"""
return self.data['image']
@property
def assertion_url(self):
"""
Get the public URL for the assertion.
"""
return self.data['json']['id']
class Meta(object):
"""
Meta information for Django's construction of the model.
"""
unique_together = (('course_id', 'user', 'mode'),)
class Intent(models.Model):
enabled = models.BooleanField(default=True)
name = models.CharField(max_length=255, null=True)
samples = JSONField(null=True)
def __str__(self):
return self.name
def test_to_python(self):
j_field = JSONField()
self.assertEqual(
loads('1'),
j_field.to_python('1')
)
self.assertEqual(
loads('"1"'),
j_field.to_python('"1"')
)
self.assertEqual(
loads('[{"a": 1}]'),
j_field.to_python('[{"a": 1}]')
)
self.assertEqual(
loads('[{"a": "1"}]'),
j_field.to_python('[{"a": "1"}]')
)
def test_get_default(self):
j_field = JSONField()
value = j_field.get_default()
self.assertEqual(value, {})
self.assertIsInstance(value, JSONDict)
j_field = JSONField(default={})
value = j_field.get_default()
self.assertEqual(value, {})
self.assertIsInstance(value, JSONDict)
j_field = JSONField(default='{}')
value = j_field.get_default()
self.assertEqual(value, {})
self.assertIsInstance(value, JSONDict)
j_field = JSONField(default=[{}])
value = j_field.get_default()
self.assertEqual(value, [{}])
self.assertIsInstance(value, JSONList)
j_field = JSONField(default='[{}]')
value = j_field.get_default()
self.assertEqual(value, [{}])
self.assertIsInstance(value, JSONList)
j_field = JSONField(default=lambda: '{}')
value = j_field.get_default()
self.assertEqual(value, {})
self.assertIsInstance(value, JSONDict)
