class Length(Transform):
"""Return the number of characters in the expression."""
function = 'LENGTH'
lookup_name = 'length'
output_field = fields.IntegerField()
def as_mysql(self, compiler, connection):
return super().as_sql(compiler, connection, function='CHAR_LENGTH')
def __init__(self, expression, substring, **extra):
"""
expression: the name of a field, or an expression returning a string
substring: a string to find inside expression
"""
if not hasattr(substring, 'resolve_expression'):
substring = Value(substring)
expressions = [expression, substring]
super().__init__(*expressions, output_field=fields.IntegerField(), **extra)
def overview(request, event_url_name):
event = get_object_or_404(Event, url_name=event_url_name)
# permission
if not event.is_admin(request.user):
return nopermission(request)
num_helpers = event.helper_set.count()
num_coordinators = 0
timeline = {}
for helper in event.helper_set.all():
if helper.is_coordinator:
num_coordinators += 1
else:
day = helper.timestamp.strftime('%Y-%m-%d')
if day in timeline:
timeline[day] += 1
else:
timeline[day] = 1
num_vegetarians = event.helper_set.filter(vegetarian=True).count()
num_shift_slots = Shift.objects.filter(job__event=event).aggregate(
Sum('number'))['number__sum']
empty_slots_expr = ExpressionWrapper(F('number') - F('num_helpers'),
output_field=fields.IntegerField())
num_empty_shift_slots = Shift.objects.filter(job__event=event) \
.annotate(num_helpers=Count('helper')) \
.annotate(empty_slots=empty_slots_expr) \
.aggregate(Sum('empty_slots'))['empty_slots__sum']
total_duration = ExpressionWrapper((F('end') - F('begin')) * F('number'),
output_field=fields.DurationField())
hours_total = Shift.objects.filter(job__event=event) \
.annotate(duration=total_duration) \
.aggregate(Sum('duration'))['duration__sum']
# sum up timeline
timeline = OrderedDict(sorted(timeline.items()))
timeline_sum = OrderedDict()
tmp = 0
for day in timeline:
tmp += timeline[day]
timeline_sum[day] = tmp
# render
context = {'event': event,
'num_helpers': num_helpers,
'num_coordinators': num_coordinators,
'num_vegetarians': num_vegetarians,
'num_shift_slots': num_shift_slots,
'num_empty_shift_slots': num_empty_shift_slots,
'hours_total': hours_total,
'timeline': timeline_sum}
return render(request, 'statistic/overview.html', context)
def __init__(self, string, substring, **extra):
"""
string: the name of a field, or an expression returning a string
substring: the name of a field, or an expression returning a string
"""
super().__init__(string,
substring,
output_field=fields.IntegerField(),
**extra)
def overview(request, event_url_name):
event = get_object_or_404(Event, url_name=event_url_name)
# permission
if not has_access(request.user, event, ACCESS_STATISTICS_VIEW):
return nopermission(request)
num_helpers = event.helper_set.count()
num_coordinators = event.all_coordinators.count()
num_vegetarians = event.helper_set.filter(vegetarian=True).count()
num_shift_slots = Shift.objects.filter(job__event=event).aggregate(
Sum('number'))['number__sum']
empty_slots_expr = ExpressionWrapper(F('number') - F('num_helpers'),
output_field=fields.IntegerField())
num_empty_shift_slots = Shift.objects.filter(job__event=event) \
.annotate(num_helpers=Count('helper')) \
.annotate(empty_slots=empty_slots_expr) \
.aggregate(Sum('empty_slots'))['empty_slots__sum']
total_duration = ExpressionWrapper((F('end') - F('begin')) * F('number'),
output_field=fields.DurationField())
try:
hours_total = Shift.objects.filter(job__event=event) \
.annotate(duration=total_duration) \
.aggregate(Sum('duration'))['duration__sum']
except (OperationalError, OverflowError):
hours_total = None
except Exception as e:
# handle psycopg2.DataError without importing psycopg2
# happens on overflow with postgresql
if 'DataError' in str(e.__class__):
hours_total = None
else:
raise e
if event.badges:
num_specialbadges = SpecialBadges.objects.filter(
event=event).aggregate(Sum('number'))['number__sum'] or 0
else:
num_specialbadges = 0
# render
context = {
'event': event,
'num_helpers': num_helpers,
'num_coordinators': num_coordinators,
'num_vegetarians': num_vegetarians,
'num_shift_slots': num_shift_slots,
'num_empty_shift_slots': num_empty_shift_slots,
'num_specialbadges': num_specialbadges,
'hours_total': hours_total
}
return render(request, 'statistic/overview.html', context)
class OrthodonticAssessment(models.EpisodeSubrecord):
_is_singleton = True
assessment_and_review = fields.BooleanField(default=False)
assess_and_refuse_treatment = fields.BooleanField(
default=False, verbose_name="Assess & refuse treatment")
assess_and_appliance_fitted = fields.BooleanField(
default=False, verbose_name="Assess & appliance fitted")
# Index of Orthodontic Treatment Need
# Only accepts 1-5
iotn = fields.IntegerField(blank=True, null=True, verbose_name="IOTN")
# Only accepts 1-10
aesthetic_component = fields.IntegerField(blank=True, null=True)
iotn_not_applicable = fields.BooleanField(
default=False, verbose_name="IOTN not applicable")
date_of_referral = fields.DateField(blank=True, null=True)
date_of_assessment = fields.DateField(blank=True, null=True)
date_of_appliance_fitted = fields.DateField(blank=True, null=True)
class MealPlan(models.Model):
LUNCH_CHOICES = tuple(
# e.g. (1, "Lunch")
(m.value, m.name.title())
for m in Meal
)
date = fields.DateField(db_index=True)
recipe_name = fields.CharField(max_length=255)
meal_id = fields.IntegerField(choices=LUNCH_CHOICES)
class BaseSubscriber(AbstractSubscriber, models.Model):
objects = BaseSubscriberManager()
email = fields.EmailField(max_length=255, verbose_name=_("Email"))
subscriber_status = fields.IntegerField(
choices=AbstractSubscriber.STATUS_CHOICES,
verbose_name=_("Subscriber status"))
class Meta(AbstractSubscriber.Meta):
swappable = "NUNTIUS_SUBSCRIBER_MODEL"
def reset_all_users_transfer():
# 1.每天凌晨汇总用户昨天使用的流量
yesterday = timezone.now() - timedelta(days=1)
traffic_list = TrafficRecord.objects.filter(create_date=yesterday).values('port', 'node_id')\
.annotate(sum_u=Sum(F('u') * F('rate') / 100, output_field=fields.IntegerField()),
sum_d=Sum(F('d') * F('rate') / 100, output_field=fields.IntegerField())).order_by()
tr_list = list()
for traf in traffic_list:
#print(traf)
tr = TrafficRecord(u=traf['sum_u'],
d=traf['sum_d'],
type=1,
port=traf['port'],
summary_date=yesterday,
node_id=traf['node_id'])
tr_list.append(tr)
TrafficRecord.objects.bulk_create(tr_list)
# 2.删除7天前的流量记录，防止表数据过大
TrafficRecord.objects.filter(summary_date__lte=timezone.now() -
timedelta(days=7)).delete()
class QuestionnaireField(models.Model):
FIELD_TYPES = (
('TXT', 'text'),
('RAD', 'radiobutton'),
('CHK', 'checkbox'),
('NUM', 'number_choice')
)
questionnaire = related.ForeignKey(Questionnaire, on_delete=models.CASCADE,
related_name='fields')
position = fields.IntegerField()
field_type = fields.CharField(max_length=3, choices=FIELD_TYPES)
text_before = fields.CharField(max_length=255)
text_after = fields.CharField(max_length=255, blank=True)
default_val = fields.CharField(max_length=255, blank=True)
min_val = fields.IntegerField(null=True)
max_val = fields.IntegerField(null=True)
class Meta:
unique_together = ('questionnaire', 'position')
ordering = ['position']
class ProductOrder(models.Model):
product = models.ForeignKey(Product)
order = models.ForeignKey(Order, related_name='products')
number = fields.IntegerField()
def __unicode__(self):
return "%(number)i %(product_name)s by %(customer_name)s in Order(%(order_id)i)" % {
'number': self.number,
'product_name': self.product.name,
'customer_name': self.order.customer,
'order_id': self.order.id
}
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 = fields.IntegerField()
def as_postgresql(self, compiler, connection):
return super().as_sql(compiler, connection, function='STRPOS')
class Jog(BasePermissions, models.Model):
owner = models.ForeignKey('User', on_delete=models.CASCADE)
date = fields.DateTimeField(null=False, blank=False)
distance = fields.IntegerField(null=False, blank=False)
time = fields.DurationField(null=False, blank=False)
@property
def average_speed(self):
"""
Calculates the average speed of the jog.
:return: The average speed.
"""
return calculate_speed(self.distance, self.time)
class Courier(models.Model):
courier_id = fields.IntegerField(primary_key=True)
foot = 'foot'
bike = 'bike'
car = 'car'
COURIER_MAX_WEIGHT = {foot: 10, bike: 15, car: 50}
COURIER_TYPE_CHOICES = ((foot, foot), (bike, bike), (car, car))
courier_type = fields.CharField(max_length=4,
choices=COURIER_TYPE_CHOICES,
default='foot',
null=False,
blank=False)
regions = pg_fields.ArrayField(fields.IntegerField())
working_hours = pg_fields.ArrayField(fields.CharField(max_length=12))
def assign_pack(self, delivery_pack, timestamp):
delivery_pack.courier = self
delivery_pack.assign_time = timestamp
delivery_pack.delivery_type = self.courier_type
delivery_pack.last_complete_time = timestamp
delivery_pack.total_weight = 0
delivery_pack.save()
def __getitem__(self, key):
return getattr(self, key)
def __setitem__(self, key, value):
setattr(self, key, value)
def get_list_of_fields(self):
return self._meta.get_fields()
class People(models.Model):
GENDER_MALE = 'Male'
GENDER_FEMALE = 'Female'
GENDER_UNDISCLOSED = 'Undisclosed'
GENDER_CHOICES = (
(GENDER_MALE, GENDER_MALE),
(GENDER_FEMALE, GENDER_FEMALE),
(GENDER_UNDISCLOSED, GENDER_UNDISCLOSED),
)
birth_year = fields.CharField(max_length=10)
eye_color = fields.CharField(max_length=10)
gender = fields.CharField(choices=GENDER_CHOICES,
default=GENDER_UNDISCLOSED,
max_length=15)
height = fields.IntegerField()
mass = fields.IntegerField()
name = fields.CharField(max_length=20, db_index=True)
created = fields.DateTimeField(auto_created=True, auto_now_add=True)
edited = fields.DateTimeField(auto_now_add=True)
class Meta:
verbose_name_plural = 'People'
class ProfileSerializer(serializers.ModelSerializer):
user = UserSerializer()
number_of_requests = fields.IntegerField()
class Meta:
model = Profile
fields = "__all__"
extra_kwargs = {
'id': {
'read_only': True
},
'user': {
'read_only': True
},
}
class DocotorSerializer(serializers.ModelSerializer):
user = UserSerializer()
number_of_requests = fields.IntegerField()
specification = SpecificationSerializer()
class Meta:
model = Doctor
fields = "__all__"
extra_kwargs = {
'id': {
'read_only': True
},
'user': {
'read_only': True
},
}
def db_type_foreignkey(self, connection):
# The database column type of a ForeignKey is the column type
# of the field to which it points. An exception is if the ForeignKey
# points to an AutoField/BigAutoField/PositiveIntegerField/
# PositiveSmallIntegerField,
# in which case the column type is simply that of an IntegerField
# (or BigIntegerField in the case of BigAutoField).
# If the database needs similar types for key fields however, the only
# thing we can do is making AutoField an IntegerField.
rel_field = self.rel.get_related_field()
if isinstance(rel_field, BigAutoField):
return fields.BigIntegerField().db_type(connection=connection)
if (isinstance(rel_field, fields.AutoField) or
(not connection.features.related_fields_match_type and isinstance(
rel_field,
(fields.PositiveIntegerField, fields.PositiveSmallIntegerField)))):
return fields.IntegerField().db_type(connection=connection)
return rel_field.db_type(connection=connection)
def create(self, validated_data):
instance = super(OrderSerializer, self).create(validated_data)
# 获取维修人员订单小于5的
Maintainer.objects.annotate()
maintainer_list = Maintainer.objects.annotate(doing=Sum(
Case(
When(order__order_status=5, then=1),
default=0,
output_field=fields.IntegerField(),
))).order_by('doing')
for maintainer in maintainer_list:
if maintainer.doing < 10:
instance.wx_user = maintainer
break
instance.order_id = instance.make_order_id()
instance.save()
return instance
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['post_list'] = Post.objects.filter(
status__iexact='PUBLISHED', content_type__iexact='ANNOUNCE')[:10]
trans_list = TrafficRecord.objects.filter(port=self.request.user.port,type=1,summary_date__gt=timezone.now()-timedelta(31)).\
values('summary_date').annotate(sum_u=Sum(F('u')*F('rate')/100, output_field=fields.IntegerField()),
sum_d=Sum(F('d')*F('rate')/100, output_field=fields.IntegerField())).order_by('summary_date')
#print(trans_list)
trans_date = list()
trans_u = list()
trans_d = list()
for tran in trans_list:
trans_date.append(tran['summary_date'].strftime('%Y-%m-%d'))
trans_u.append(round(tran['sum_u'] / TO_MB, 2))
trans_d.append(round(tran['sum_d'] / TO_MB, 2))
context['trans_date'] = trans_date
context['trans_u'] = trans_u
context['trans_d'] = trans_d
return context
class DoctorUserSerializer(serializers.ModelSerializer):
user = UserSerializer()
number_of_requests = fields.IntegerField()
isAlreadyDoctorOfThisUser = fields.BooleanField()
specification = SpecificationSerializer()
def to_representation(self, instance):
rep = super().to_representation(instance)
user = None
request = self.context.get("request", False)
if request:
user = request.user
print(get_user_by_type(user), instance.patients.all())
inList = get_user_by_type(user) in instance.patients.all()
rep['isAlreadyDoctorOfThisUser'] = inList
rep['isRequested'] = Request.objects.filter(
sender=user, reciever=instance.user,
type=2 if inList else 1).count() > 0
return rep
class Meta:
model = Profile
fields = [
'user', "name", 'surname', 'sex', 'contact_number', 'specification'
]
extra_kwargs = {
'id': {
'read_only': True
},
'user': {
'read_only': True
},
'specification': {
'read_only': True
}
}
def _resolve_output_field(self):
if isinstance(self.value, str):
return fields.CharField()
if isinstance(self.value, bool):
return fields.BooleanField()
if isinstance(self.value, int):
return fields.IntegerField()
if isinstance(self.value, float):
return fields.FloatField()
if isinstance(self.value, datetime.datetime):
return fields.DateTimeField()
if isinstance(self.value, datetime.date):
return fields.DateField()
if isinstance(self.value, datetime.time):
return fields.TimeField()
if isinstance(self.value, datetime.timedelta):
return fields.DurationField()
if isinstance(self.value, Decimal):
return fields.DecimalField()
if isinstance(self.value, bytes):
return fields.BinaryField()
if isinstance(self.value, UUID):
return fields.UUIDField()
def __init__(self, expression, **extra):
output_field = extra.pop('output_field', fields.IntegerField())
super(Length, self).__init__(expression,
output_field=output_field,
**extra)
def output_field(self):
return fields.IntegerField()
def __init__(self, expression, *, output_field=None, **extra):
super().__init__(expression, output_field=output_field or fields.IntegerField(), **extra)
class MedianTest(models.Model):
val_int = fields.IntegerField()
val_float = fields.FloatField()
class XSerializer(serializers.Serializer):
field = fields.IntegerField()
class StringAggTest(models.Model):
val_str = fields.CharField(max_length=10)
val_int = fields.IntegerField()
class NLevel(Transform):
lookup_name = "depth"
function = "nlevel"
output_field = fields.IntegerField()
class FirstLastTest(models.Model):
ts = fields.DateField()
val = fields.IntegerField()
