class Article(Model):
id_arxiv = CharField(max_length=20, unique=True)
categories = CustomTreeManyToManyField('Category', blank=True)
# TODO - validate that only contains a whitelist of html tags
html_meta = TextField()
is_processed = BooleanField(default=False, verbose_name='Processed')
date_submitted = DateField()
date_updated = DateField(verbose_name='Date')
objects = ArticleQuerySet.as_manager()
@cached_property
def title(self):
soup = BeautifulSoup(self.html_meta, 'html.parser')
title_tag = soup.select_one('.list-title')
title_tag.select_one('span').decompose()
return title_tag.text.strip()
@cached_property
def categories_str(self):
cats = [c._name_choices_str for c in self.categories.all()]
return mark_safe('<br>'.join(cats))
categories_str.short_description = 'Categories'
def html_meta_safe(self):
return mark_safe(self.html_meta)
html_meta_safe.short_description = 'Abstract'
def __str__(self):
return "arXiv:{}".format(self.id_arxiv)
class NooksPayoutSchedule(models.Model):
start_date = DateField()
end_date = DateField()
payout_date = DateField()
is_picked = BooleanField()
def __str__(self) -> str:
return str(self.payout_date)
def obtener_logs_por_dia(persona):
tasks_por_dia = []
dias = PersonaTaskRelacion.objects.filter(persona=persona).annotate(
dia=Cast('inicio', DateField())).values_list(
'dia', flat=True).distinct().order_by('-dia')
for dia in dias:
tasks = PersonaTaskRelacion.objects.filter(persona=persona).annotate(
dia=Cast('inicio', DateField())).filter(dia=dia)
tasks_por_dia.append(TasksPorDia(tasks, dia))
return tasks_por_dia
class Information(LineItem):
city = CharField(max_length=100, blank=False, null=False, default="")
start = DateField(blank=False, null=False, default=timezone.now)
end = DateField(blank=False, null=False, default=timezone.now)
current = BooleanField(blank=False, null=False, default=False)
class Meta:
abstract = True
def __str__(self):
return f"{super(Information, self).__str__()} city: {self.city}\nstart: {self.start}\nend: {self.end}\n"
def _get_weekday_to_date(self):
"""Get DB function to convert a weekday to a date."""
return ExpressionWrapper(
Func(
Concat(F("year"), F("week")),
Value("IYYYIW"),
output_field=DateField(),
function="TO_DATE",
) + F("period__weekday"),
output_field=DateField(),
)
class Trade(models.Model):
class Meta:
permissions = (('CAN_VIEW','Can view public instances'),)
CHOICES=[('a', 'acceppted'),('p','pending'),('c','closed')]
date_created = DateField(auto_now_add=True)
date_completed = DateField(null=True)
status = CharField(max_length=1, choices=CHOICES, default='p')
public = BooleanField(default=False)
cards = ManyToManyField(Pokemon)
creator = ForeignKey(User, on_delete=models.CASCADE)
def _get_weekday_to_date(self, weekday_name, year_name="year", week_name="week"):
"""Get a ORM function which converts a weekday, a week and a year to a date."""
return ExpressionWrapper(
Func(
Concat(F(year_name), F(week_name)),
Value("IYYYIW"),
output_field=DateField(),
function="TO_DATE",
)
+ F(weekday_name),
output_field=DateField(),
)
def detailed_log_entries(request, u, date, page, *args, **kwargs):
pages = ServerChat.objects.filter(user=u)\
.annotate(created_date=Cast('created_at', DateField()))\
.values('created_date')\
.distinct()\
.order_by('-created_date')
date = pages[date - 1]['created_date']
logs = ServerChat.objects.annotate(created_date=Cast('created_at', DateField()))\
.filter(user=u, created_date=date).order_by('created_at')
return renderer(request, 'components/players/detailed/logs/entry.pug',
logs, page)
class Perfil(models.Model):
STATUS = (
('F', 'Feminino'),
('M', 'Masculino'),
('+', 'Qualquer outra coisa que você possa ser ou não ser'),
)
nome = models.CharField(max_length=100)
cpf = models.CharField(max_length=18, unique=True)
sexo = models.CharField(
max_length=1,
choices=STATUS,
)
nascimento = DateField()
graudeparentesco = models.CharField(max_length=100)
comorbidades = models.TextField(max_length=100, blank=True)
pais = models.CharField(max_length=100)
estado = models.CharField(max_length=2)
cidade = models.CharField(max_length=100)
rua = models.CharField(max_length=200, blank=True)
bairro = models.CharField(max_length=100, blank=True)
complemento = models.CharField(max_length=100, blank=True)
medicoresponsavel = models.CharField(max_length=100, blank=True)
especializacaodomedico = models.CharField(max_length=100, blank=True)
hospital = models.CharField(max_length=100, blank=True)
telefone = models.CharField(max_length=18)
sintomas = models.TextField(max_length=200, blank=True)
altura = models.FloatField(max_length=100, blank=True)
peso = models.IntegerField(blank=True)
testesrealizados = models.CharField(max_length=100, blank=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
return self.nome
def ajax_task_stats(request):
filter_date_from = date.today() + timedelta(days=-30)
filter_date_to = date.today() + timedelta(days=1)
print(filter_date_from)
print(filter_date_to)
log_rows = {}
log_types = ['all', TASK_LOG_DONE, TASK_LOG_POSTPONE]
for log_type in log_types:
qs = Changelog.objects.filter(task_id__user_id=request.user.id)
if not log_type == 'all':
qs = qs.filter(action=log_type)
log_rows[log_type] = (qs.values(
_id=Cast('log_date', DateField())).annotate(
count=Count('task_id', distinct=True)).filter(
log_date__range=[filter_date_from, filter_date_to
]).order_by('_id'))
print(log_rows[log_type].query)
log_rows[log_type] = list(log_rows[log_type].all())
data = {
'result': {
'data_all': log_rows['all'],
'data_yes': log_rows[TASK_LOG_DONE],
'data_no': log_rows[TASK_LOG_POSTPONE],
}
}
return JsonResponse(data)
def matches(req):
profile = (DP.objects.select_related('_city').prefetch_related(
'likes',
'dislikes').prefetch_related('likes__liked',
'dislikes__disliked').get(user=req.user))
lat, long = profile.city.latitude, profile.city.longtitude
distance = ((F('_city__latitude') - lat)**2 +
(F('_city__longtitude') - long)**2)
matches = (profile.matches.filter(~Q(avatar=None)).select_related(
'avatar').annotate(distance=distance).annotate(
is_vip=DP.is_vip_annotation()).annotate(
last_seen_date=Cast('last_seen', DateField())).order_by(
'is_fake', '-last_seen_date', '-is_vip', '-last_seen',
'distance')[:settings.MATCHES_PER_GAME])
jsoned = [{
'pk':
p.pk,
'name':
p.name,
'birthday':
p.birthday,
'thumbnailUrl': (p.avatar.small_thumbnail_url if p.avatar else None),
'avatarUrl':
p.avatar.image.url if p.avatar else None,
'likedMe':
p.liked_me,
'status':
p.status,
'canSendMessage':
req.user.has_perm('send_message_to', p)
} for p in matches]
return disable_browser_cache(JsonResponse({'matches': jsoned}))
class Certificacao(models.Model):
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
nome = models.CharField("Nome da certificação", blank=True, max_length=150)
selo_x = models.PositiveSmallIntegerField("Selo X",
default=0,
editable=False)
selo_y = models.PositiveSmallIntegerField("Selo Y",
default=0,
editable=False)
selo = models.ImageField(upload_to="certificacoes/logos",
height_field="selo_y",
width_field="selo_x",
max_length=600,
blank=True)
desc = models.TextField("Descrição da certificação", blank=True)
preco = models.DecimalField("Investimento",
blank=True,
max_digits=9,
decimal_places=2,
null=True)
quando = DateField("Quando certificamos", blank=True, null=True)
def __str__(self):
return self.nome
class Meta:
verbose_name = "Certificação"
verbose_name_plural = "Certificações"
class Task(models.Model):
title = models.CharField(max_length=80)
descriptions = models.TextField()
due_date = DateField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
objects = TaskManager() # <-- ADD THIS
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())
)
def progress_log(request):
filter_category_id = -1
filter_date_from = date.today() + timedelta(days=-30)
filter_date_to = date.today() + timedelta(days=1)
qs = Changelog.objects.filter(task_id__user_id=request.user.id)
qs = qs.filter(action=TASK_LOG_DONE)
log_rows = (qs.values(_id=Cast('log_date', DateField(
))).annotate(count=Count('task_id', distinct=True)).filter(
log_date__range=[filter_date_from, filter_date_to]).order_by('-_id'))
print(log_rows.query)
log_rows = list(log_rows.all())
log_rows = [{'date_block': x['_id']} for x in log_rows]
for k, dt in enumerate(log_rows):
current_date_from = dt['date_block']
current_date_to = current_date_from + timedelta(days=1)
task_obj = Task.objects.distinct().filter(
active=True,
user_id=request.user.id,
changelog__action=TASK_LOG_DONE,
changelog__log_date__range=[current_date_from, current_date_to])
print(task_obj.query)
log_rows[k]['task_list'] = task_obj.order_by('priority').all()
# return HttpResponse(str(log_rows))
template = loader.get_template('main/progress_log.html')
context = {
'log_rows': log_rows,
}
return HttpResponse(template.render(context, request))
class _ModelWithOptionalDateABC(
_ModelWithObjectsManagerAndDefaultMetaOptionsABC):
# docs.djangoproject.com/en/dev/ref/models/fields/#datefield
date: DateField = \
DateField(
verbose_name='Date',
help_text='Date',
null=True,
blank=True,
choices=None,
db_column=None,
db_index=True,
db_tablespace=None,
default=None,
editable=True,
# error_messages={},
primary_key=False,
unique=False,
unique_for_date=None,
unique_for_month=None,
unique_for_year=None,
# validators=(),
auto_now_add=False,
auto_now=False)
class Meta(_ModelWithObjectsManagerAndDefaultMetaOptionsABC.Meta):
# pylint: disable=too-few-public-methods
"""Metadata."""
abstract = True
def create_table(fields, table_name, title):
table_name += str(int(time.time()))
dynfields = [('id', AutoField(primary_key=True))]
type = None
for field in fields:
if field['type'] == 'char':
type = CharField(max_length=255)
elif field['type'] == 'date':
type = DateField()
elif field['type'] == 'int':
type = IntegerField()
name = field['id']
dynfields.append((name, type))
r = Row(row_name=name,
title=field['title'],
type=field['type'],
table_name=table_name)
r.save()
dynfields = tuple(dynfields)
try:
db.create_table(table_name, dynfields)
r = Table(title=title, table_name=table_name)
r.save()
except MySQLdb.OperationalError as e:
print e.message
except Exception as e:
print e.message
class _ModelWithNonNullableDateMixInABC(Model):
date = \
DateField( # https://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.DateField
null=False,
blank=False,
choices=None,
db_column=None,
db_index=True,
db_tablespace=None,
default=None,
editable=True,
# error_messages=None,
help_text='Date',
primary_key=False,
unique=False,
unique_for_date=None,
unique_for_month=None,
unique_for_year=None,
verbose_name='Date',
# validators=(),
auto_now_add=False,
auto_now=False)
class Meta:
abstract = True
class Modul(models.Model):
"""
Modul er en 'time' eller lektion, der er/bliver `afholdt` på en bestemt dag som del af et Forløb.
"""
id = AutoField(primary_key=True,
verbose_name='Modul-løbenummer (automatisk)')
forløb = ForeignKey('Forløb', on_delete=models.RESTRICT, null=True)
oprettet = models.DateTimeField(
#default=timezone.now()
auto_now_add=
True, # https://docs.djangoproject.com/en/3.2/ref/models/fields/#django.db.models.DateField.auto_now_add
)
opdateret = models.DateTimeField( # NB: Dato odateres ved Model.save() ikke ved QuerySet.update(), se dokumenation!
#default=timezone.now(),
auto_now=
True, # https://docs.djangoproject.com/en/3.2/ref/models/fields/#django.db.models.DateField.auto_now
)
afholdt = DateField(help_text='Planlagt / faktisk dato for modulet')
class Meta:
ordering = ['afholdt', 'id']
verbose_name_plural = 'moduler'
def __str__(self):
return f"Modul {self.id} '{self.forløb.titel}', {self.afholdt} ({self.forløb.klasse})."
def get_absolute_url(self):
"""Returnerer URL, der tilgår et bestemt Modul."""
return reverse('modul_tildel', args=[str(self.id)])
def status_oj(request):
if not request.user.is_superuser or not request.user.is_staff:
return HttpResponseBadRequest(
_("You must be admin to view this content."),
content_type='text/plain')
queryset = Submission.objects.filter(date__gt=datetime.datetime.today() -
datetime.timedelta(days=30))
context = {'title': _('OJ Status')}
submissions = (queryset.annotate(
date_only=Cast(F('date'), DateField())).order_by('date').values(
'date_only', 'result').annotate(count=Count('result')).values_list(
'date_only', 'result', 'count'))
labels = list(
set(item[0].isoformat()
for item in submissions.values_list('date_only')))
labels.sort()
num_date = len(labels)
result_order = ["AC", "WA", "TLE", "CE", "ERR"]
result_data = defaultdict(partial(list, [0] * num_date))
for date, result, count in submissions:
result_data[result if result in result_order else "ERR"][labels.index(
date.isoformat())] += count
submissions_count = {
'labels':
labels,
'datasets': [{
'label':
name,
'backgroundColor':
settings.DMOJ_STATS_SUBMISSION_RESULT_COLORS.get(name, "ERR"),
'data':
result_data[name],
} for name in result_order],
}
stats = {
'language_count':
get_pie_chart(
queryset.values('language__name').annotate(
count=Count('language__name')).filter(
count__gt=0).order_by('-count').values_list(
'language__name', 'count'), ),
'submission_count':
submissions_count,
'ac_rate':
get_pie_chart(
queryset.values('result').annotate(
count=Count('result')).order_by('-count').values_list(
'result', 'count').filter(~Q(
result__in=["IR", "AB", "MLE", "OLE", "IE"])), ),
}
context['stats'] = mark_safe(json.dumps(stats))
return render(request, 'status/oj-status.html', context)
class Bond(models.Model):
isin = CharField(max_length=12)
size = DecimalField(max_digits=20, decimal_places=3)
currency = CharField(max_length=3)
maturity = DateField()
lei = CharField(max_length=20)
legal_name = CharField(max_length=128, blank=True, null=True)
user = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
def __repr__(self):
return f'Bond ({self.isin})'
@classmethod
def get_legal_name_from_gleif(cls, lei: str) -> Optional[str]:
try:
logging.info(f"Getting legal name for LEI {lei} from GLEIF's API")
r = requests.get(
f'https://leilookup.gleif.org/api/v2/leirecords?lei={lei}')
r.raise_for_status()
legal_name = r.json()[0]['Entity']['LegalName']['$']
except Exception as ex:
logging.exception(
f'Could not fetch legal name of bond (LEI={lei}) from GLEIF API: {ex}'
)
legal_name = None
return legal_name
def get_context_data(self, **kwargs):
context = super(UserAboutPage, self).get_context_data(**kwargs)
ratings = context['ratings'] = self.object.ratings.order_by('-contest__end_time').select_related('contest') \
.defer('contest__description')
context['rating_data'] = mark_safe(
json.dumps([{
'label':
rating.contest.name,
'rating':
rating.rating,
'ranking':
rating.rank,
'link':
reverse('contest_ranking', args=(rating.contest.key, )),
'timestamp':
(rating.contest.end_time - EPOCH).total_seconds() * 1000,
'date':
date_format(rating.contest.end_time, _('M j, Y, G:i')),
'class':
rating_class(rating.rating),
'height':
'%.3fem' % rating_progress(rating.rating),
} for rating in ratings]))
context['awards'] = self.get_awards(ratings)
if ratings:
user_data = self.object.ratings.aggregate(Min('rating'),
Max('rating'))
global_data = Rating.objects.aggregate(Min('rating'),
Max('rating'))
min_ever, max_ever = global_data['rating__min'], global_data[
'rating__max']
min_user, max_user = user_data['rating__min'], user_data[
'rating__max']
delta = max_user - min_user
ratio = (max_ever - max_user) / (
max_ever - min_ever) if max_ever != min_ever else 1.0
context['max_graph'] = max_user + ratio * delta
context['min_graph'] = min_user + ratio * delta - delta
submissions = (self.object.submission_set.annotate(
date_only=Cast('date', DateField())).values('date_only').annotate(
cnt=Count('id')))
context['submission_data'] = mark_safe(
json.dumps({
date_counts['date_only'].isoformat(): date_counts['cnt']
for date_counts in submissions
}))
context['submission_metadata'] = mark_safe(
json.dumps({
'min_year': (self.object.submission_set.annotate(
year_only=ExtractYear('date')).aggregate(
min_year=Min('year_only'))['min_year']),
}))
return context
class ResetPasswordExtra(models.Model):
user = models.OneToOneField(
settings.AUTH_USER_MODEL,
models.CASCADE,
primary_key=True,
related_name="password_details",
)
password_last_updated_at = DateField()
class TeslaReturn(Model):
label = CharField(max_length=50)
return_date = DateField()
return_amount = DecimalField(max_digits=20, decimal_places=10)
created_date = DateTimeField(auto_now_add=True)
class Meta(object):
db_table = 'tesla_return'
def test_convert_values_to_handle_null_value(self):
from django.db.backends.sqlite3.base import DatabaseOperations
convert_values = DatabaseOperations(connection).convert_values
self.assertIsNone(convert_values(None, AutoField(primary_key=True)))
self.assertIsNone(convert_values(None, DateField()))
self.assertIsNone(convert_values(None, DateTimeField()))
self.assertIsNone(convert_values(None, DecimalField()))
self.assertIsNone(convert_values(None, IntegerField()))
self.assertIsNone(convert_values(None, TimeField()))
class Dado(models.Model):
regiao = models.CharField(max_length=100)
estado = models.CharField(max_length=3)
municipio = models.CharField(max_length=100)
data = DateField()
casosAcumulado = models.IntegerField()
casosNovos = models.IntegerField()
obitosAcumulado = models.IntegerField()
obitosNovos = models.IntegerField()
class Truck(models.Model):
brand = models.CharField(max_length=50)
hp = models.IntegerField()
cc = models.IntegerField()
type = models.CharField(max_length=20)
year_made = DateField()
def __str__(self):
return self.brand
class Task(models.Model):
user = models.ForeignKey(EndUser, null=True, on_delete=models.SET_NULL)
title = models.CharField(max_length=200)
date_created = DateField(auto_now=True)
#due_date= DateField(default = timezone.now()+ timezone.timedelta(days=1), null=True) # tomorrow
#isImportant = BooleanField(default=False) # star amblem at right1
tags = models.ManyToManyField(Tag, blank=True)
def __str__(self):
return self.title
class Software(models.Model):
title = CharField(max_length=1000, blank=True, default="")
versionName = CharField(max_length=1000, blank=True, default="")
versionCode = IntegerField(default=0)
lastUpdate = DateField(default=0)
executable = FileField(upload_to="softwares/collector")
class TruncDate(TruncBase):
kind = "date"
lookup_name = "date"
output_field = DateField()
def as_sql(self, compiler, connection):
# Cast to date rather than truncate to date.
sql, params = compiler.compile(self.lhs)
tzname = self.get_tzname()
return connection.ops.datetime_cast_date_sql(sql, tuple(params), tzname)
