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()