def getcartproducts(request): products = [] r_token = request.META['HTTP_AUTHORIZATION'] new_token = r_token.split(' ', 1)[1] token = Token.objects.filter(key=new_token).first() buyer = Buyer.objects.filter(user_ptr_id=token.user.id).first() cart_items = Order_Product.objects.filter(buyer=buyer, checkout__isnull=True) for order in cart_items: if order.quantity is not None: print(order.quantity) product = Product.objects.filter(id=order.product.id).annotate(order_id=Sum(order.id, output_field=IntegerField()),quantity=Sum(order.quantity, output_field=FloatField()), total=Sum(order.total, output_field=FloatField())).first() print(product.quantity) products.append(product) data = CustomCartSerializer(products, many=True) context = { 'data': data.data } return Response(data.data,status=status.HTTP_200_OK)
class Month(Func): function = 'EXTRACT' template = '%(function)s(MONTH from %(expressions)s)' output_field = IntegerField()
def get_context_data(self, **kwargs): context = super(AvailableTasksView, self).get_context_data(**kwargs) context['form'] = self.form context['tab_count'] = context['paginator'].count if self.priority: workflows = Workflow.objects\ .unclosed()\ .filter(priority=True)\ .select_related('country', 'locality')\ .annotate( n_tasks_open=Subquery( Task.objects.filter(workflows=OuterRef('pk'), state=Task.OPEN, assigned_to=None) .values('workflows__pk') .annotate(cnt=Count(1)) .values('cnt'), output_field=IntegerField()), n_tasks_assigned=Subquery( Task.objects.filter(workflows=OuterRef('pk'), state=Task.OPEN) .exclude(assigned_to=None) .values('workflows__pk') .annotate(cnt=Count(1)) .values('cnt'), output_field=IntegerField()), n_tasks_pending_review=Subquery( Task.objects.filter(workflows=OuterRef('pk'), state=Task.PENDING_REVIEW) .values('workflows__pk') .annotate(cnt=Count(1)) .values('cnt'), output_field=IntegerField()), n_tasks_done=Subquery( Task.objects.filter(workflows=OuterRef('pk'), state=Task.DONE) .values('workflows__pk') .annotate(cnt=Count(1)) .values('cnt'), output_field=IntegerField()), n_tasks_cancelled=Subquery( Task.objects.filter(workflows=OuterRef('pk'), state=Task.CANCELLED) .values('workflows__pk') .annotate(cnt=Count(1)) .values('cnt'), output_field=IntegerField()), ).all() # sort by due date (desc + nulls last), then by id (asc) def key(x): return [ -x.due_date.toordinal() if x.due_date else math.inf, x.pk ] context['priority_workflows'] = sorted(workflows, key=key) for w in context['priority_workflows']: w.task_counts = [(state, getattr(w, f'n_tasks_{state}') or 0, state.replace('_', ' ')) for state in [ 'open', 'assigned', 'pending_review', 'done', 'cancelled' ]] w.n_tasks = sum(n for s, n, l in w.task_counts) w.n_tasks_complete = (w.n_tasks_done or 0) + (w.n_tasks_cancelled or 0) w.pct_complete = (w.n_tasks_complete or 0) / (w.n_tasks or 1) * 100.0 return context
class RegrCount(StatAggregate): function = 'REGR_COUNT' output_field = IntegerField() def convert_value(self, value, expression, connection): return 0 if value is None else value
class Job(Model): jobid = CharField( null=False, max_length=32, blank=True, default="", db_index=True ) jobname = CharField(null=False, max_length=128, blank=True, default="") queue = CharField( null=False, max_length=128, blank=True, default="" ) qtime = IntegerField(null=False, blank=True, default=0, db_index=True) starttime = IntegerField(null=False, blank=True, default=0) endtime = IntegerField(null=False, blank=True, default=0) submiter = CharField( null=False, max_length=32, blank=True, default="" ) submit_args = CharField(null=False, max_length=260, blank=True, default="") jobstatus = CharField( null=False, max_length=12, blank=True, default="" ) walltime = CharField(null=False, max_length=24, blank=True, default="") nodescount = IntegerField(null=False, blank=True, default=0) cpuscount = IntegerField(null=False, blank=True, default=0) priority = CharField(null=False, max_length=12, blank=True, default="") exechosts = CharField(null=False, max_length=512, blank=True, default="") type = CharField(null=False, max_length=24, blank=True, default="") jobfilename = CharField(null=False, max_length=260, blank=True, default="") workingdir = CharField(null=False, max_length=260, blank=True, default="") mail = CharField(null=False, max_length=260, blank=True, default="") mailtrigger = CharField(null=False, max_length=12, blank=True, default="") mpi_prog = CharField(null=False, max_length=260, blank=True, default="") mpi_prog_arguments = CharField( null=False, max_length=64, blank=True, default="" ) pnodescount = IntegerField(null=False, blank=True, default=0) ppn = IntegerField(null=False, blank=True, default=0) pmem = IntegerField(null=False, blank=True, default=0) status = CharField( null=False, max_length=24, blank=True, default="" ) isdeleted = BooleanField(null=False, blank=True, default=False) operatestatus = CharField( null=False, max_length=24, blank=True, default="" ) aioperatestatus = CharField( null=False, max_length=24, blank=True, default="" ) charge = IntegerField(null=False, blank=True, default=0) wallduration = IntegerField(null=False, blank=True, default=0) billgroup = CharField(null=False, max_length=32, blank=True, default="") workspace = CharField(null=False, max_length=260, blank=True, default="") json_body = TextField(null=False, blank=True, default="") gpuscount = IntegerField(null=False, blank=True, default=0) gpucharge = IntegerField(null=False, blank=True, default=0) gpusexechosts = CharField( null=False, max_length=512, blank=True, default="" ) resumejobid = CharField(null=False, max_length=32, blank=True, default="") errfile = TextField(null=False, blank=True, default="") outfile = TextField(null=False, blank=True, default="") def get_absolute_url(self): return "/jobs/%i" % self.id def as_dict(self, **karg): import datetime import time def timeToUTC(times): return str(datetime.datetime.utcfromtimestamp(times)) fields = karg.get('fields', []) exclude = karg.get('exclude', []) if karg.get('overview') is True: fields = [ 'id', "jobid", "jobname", "queue", "status", "jobstatus", "qtime", "starttime", "endtime", "nodescount", "cpuscount", "workingdir", "type", "jobfilename", "submit_args", "charge", "submiter", "walltime", "priority", "exechosts", "mail", "mailtrigger", "mpi_prog", "mpi_prog_arguments", "pnodescount", "ppn", "pmem", "operatestatus", "aioperatestatus", "wallduration", "billgroup", "workspace" ] data = model_to_dict(self, fields=fields, exclude=exclude) # data["url"] = self.get_absolute_url() data["currtime"] = timeToUTC(int(time.time())) data["timezone"] = time.timezone data["starttime"] = timeToUTC(data["starttime"]) data["endtime"] = timeToUTC(data["endtime"]) data["qtime"] = timeToUTC(data["qtime"]) return data def save(self, *args, **kwargs): if not self.id: job_status_mapping = { "c": "completed", "r": "running", "q": "queueing", "s": "suspending", "w": "waiting", "h": "holding" } op_status_mapping = { "cancelling": "cancelling", "creating": "creating", "cancelled": "cancelled", "createfailed": "createfailed" } if self.jobstatus.lower(): self.status = job_status_mapping[self.jobstatus.lower()] if self.operatestatus: self.status = op_status_mapping[self.operatestatus] super(Job, self).save(*args, **kwargs)
def get_queryset(self, pk=None): """All videos except for null ones.""" queryset = Video.objects.filter(is_unlisted=False).values() request = self.request fields = [x.name for x in Video._meta.fields] for f in VIDEO_FIELDS: fields.remove(f) def get_score_annotation(user_preferences_vector): """Returns an sql object annotating queries with the video ratings (sclar product).""" return sum([ F(f) * v for f, v in zip(VIDEO_FIELDS, user_preferences_vector) ]) features = self.get_features_from_request() search_username = self.need_scores_for_username() # computing score inside the database if search_username: queryset = queryset.values(*fields) queryset = queryset.annotate( **{key: F(f'videorating__{key}') for key in VIDEO_FIELDS}, user=F('videorating__user__user__username')).filter( user=search_username) # for myself, allow showing public/non-public videos if search_username == request.user.username: is_public = request.query_params.get('show_all_my_videos', 'true') == 'false' print(is_public) else: # for other people, only show public videos is_public = True # keeping only public videos if is_public: queryset = VideoRatingPrivacy._annotate_privacy( queryset, prefix='videoratingprivacy', field_user=None, filter_add={ 'videoratingprivacy__user__user__username': search_username }) queryset = queryset.filter(_is_public=True) queryset = queryset.annotate( rating_n_experts=Value(1, IntegerField())) q1 = Q(expertrating_video_1__user__user__username=search_username) q2 = Q(expertrating_video_2__user__user__username=search_username) c1 = Count('expertrating_video_1', q1, distinct=True) c2 = Count('expertrating_video_2', q2, distinct=True) queryset = queryset.annotate(rating_n_ratings=c1 + c2) # logging model usage in search if self.request.user.is_authenticated: RepresentativeModelUsage.objects.get_or_create( viewer=UserPreferences.objects.get( user__username=self.request.user.username), model=UserPreferences.objects.get( user__username=search_username)) queryset = queryset.annotate( score_preferences_term=get_score_annotation(features)) queryset = queryset.annotate( score_search_term_=Value(0.0, FloatField())) if request.query_params.get('search'): # computing the postgres score for search if connection.vendor.startswith('postgres'): s_query = request.query_params.get('search', '') def word_to_query(w): """Convert one word into a query.""" queries = [] queries.append(SearchQuery(w, search_type='raw')) queries.append(SearchQuery(w + ':*', search_type='raw')) return reduce(lambda x, y: x | y, queries) def words_to_query(s_query, max_len=100, max_word_len=20): """Convert a string with words into a SearchQuery.""" s_query = s_query[:max_len] s_query = s_query.split(' ') s_query = [ ''.join(filter(str.isalnum, x)) for x in s_query ] s_query = [ x for x in s_query if 1 <= len(x) <= max_word_len ] s_query = [word_to_query(x) for x in s_query] if not s_query: return SearchQuery('') return reduce(lambda x, y: x & y, s_query) s_query = words_to_query(s_query) s_vectors = [ SearchVector(f, weight=w) for f, w in zip(self.search_fields, self.search_weights) ] s_vector = reduce(lambda x, y: x + y, s_vectors) queryset = queryset.annotate( score_search_term_=SearchRank(s_vector, s_query)) else: # in other databases, using basic filtering queryset = filters_.SearchFilter().filter_queryset( self.request, queryset, self) queryset = queryset.annotate( score_search_term_=Value(1.0, FloatField())) queryset = queryset.annotate( score_search_term=F('score_search_term_') * VideoSearchEngine.VIDEO_SEARCH_COEFF) queryset = queryset.annotate(score=F('score_preferences_term') + F('score_search_term')) return queryset
class EquipmentInstanceAlertPeriod(Model): """Equipment Instance Alert Period.""" RELATED_NAME = 'equipment_instance_alert_periods' RELATED_QUERY_NAME = 'equipment_instance_alert_period' equipment_unique_type_group = \ ForeignKey( to=EquipmentUniqueTypeGroup, related_name=RELATED_NAME, related_query_name=RELATED_QUERY_NAME, blank=False, null=False, on_delete=PROTECT) equipment_instance = \ ForeignKey( to=EquipmentInstance, related_name=RELATED_NAME, related_query_name=RELATED_QUERY_NAME, blank=False, null=False, on_delete=PROTECT) risk_score_name = \ CharField( max_length=MAX_CHAR_LEN, blank=False, null=False, unique=False, db_index=True) threshold = \ FloatField( blank=False, null=False, default=0, db_index=True) from_date = \ DateField( blank=False, null=False, auto_now=False, auto_created=False, default=None, db_index=True) to_date = \ DateField( blank=False, null=False, auto_now=False, auto_created=False, default=None, db_index=True) date_range = \ DateRangeField( blank=True, null=True) duration = \ IntegerField( blank=False, null=False, default=0) cumulative_excess_risk_score = \ FloatField( blank=False, null=False, default=0) approx_average_risk_score = \ FloatField( blank=False, null=False, default=0) last_risk_score = \ FloatField( blank=False, null=False, default=0) ongoing = \ BooleanField( blank=False, null=False, default=False, db_index=True) info = \ JSONField( blank=True, null=True, default=dict) diagnosis_status = \ ForeignKey( to=AlertDiagnosisStatus, blank=True, null=True, on_delete=PROTECT) equipment_instance_alarm_periods = \ ManyToManyField( to=EquipmentInstanceAlarmPeriod, through=(EquipmentInstanceAlarmPeriod .equipment_instance_alert_periods.through), related_name=RELATED_NAME + '_reverse', related_query_name=RELATED_QUERY_NAME, blank=True) has_associated_equipment_instance_alarm_periods = \ BooleanField( blank=False, null=False, default=False, db_index=True) equipment_instance_problem_diagnoses = \ ManyToManyField( to=EquipmentInstanceProblemDiagnosis, through=(EquipmentInstanceProblemDiagnosis .equipment_instance_alert_periods.through), related_name=RELATED_NAME + '_reverse', related_query_name=RELATED_QUERY_NAME, blank=True) has_associated_equipment_instance_problem_diagnoses = \ BooleanField( blank=False, null=False, default=False, db_index=True) class Meta: """Metadata.""" verbose_name = 'Equipment Instance Alert Period' verbose_name_plural = 'Equipment Instance Alert Periods' unique_together = \ ('equipment_unique_type_group', 'equipment_instance', 'risk_score_name', 'threshold', 'from_date'), \ ('equipment_unique_type_group', 'equipment_instance', 'risk_score_name', 'threshold', 'to_date') ordering = \ 'diagnosis_status', \ '-ongoing', \ 'risk_score_name', \ '-threshold', \ '-cumulative_excess_risk_score' def __str__(self): """Return string repr.""" if self.diagnosis_status is None: self.save() return (f'{self.diagnosis_status.name.upper()}: ' + ( 'ONGOING ' if self.ongoing else '' ) + 'Alert on ' + ( f'{self.equipment_unique_type_group.equipment_general_type.name.upper()} ' # noqa: E501 f'{self.equipment_unique_type_group.name} ' f'#{self.equipment_instance.name} ' f'from {self.from_date} to {self.to_date} ' f'w Approx Avg Risk Score {self.approx_average_risk_score:,.1f} ' f'(Last: {self.last_risk_score:,.1f}) ' f'(based on {self.risk_score_name} > {self.threshold}) ' f'for {self.duration:,} Day(s)')) def save(self, *args, **kwargs): """Save.""" self.date_range = \ DateRange( lower=self.from_date, upper=self.to_date, bounds='[]', empty=False) self.duration = duration = \ (self.to_date - self.from_date).days + 1 self.approx_average_risk_score = \ self.threshold + \ (self.cumulative_excess_risk_score / duration) if self.diagnosis_status is None: self.diagnosis_status = \ AlertDiagnosisStatus.objects.get_or_create(index=0)[0] super().save(*args, **kwargs)
def exclude_records_by_age_for_column(exclude_config, column): return Case(When(~Q(**exclude_config), then=F(column)), default=0, output_field=IntegerField())
def with_month_year(self): return self.annotate(month=Func( F("created_on"), function="month", output_field=IntegerField())).annotate(year=Func( F("created_on"), function="year", output_field=IntegerField()))
def addReview(request,product_id): review = [] r_token = request.META['HTTP_AUTHORIZATION'] new_token = r_token.split(' ', 1)[1] token = Token.objects.filter(key=new_token).first() buyer = Buyer.objects.filter(user_ptr_id=token.user.id).first() product = Product.objects.filter(id = product_id).first() comment = request.data.get("comments") ratings = request.data.get("ratings") new_review = Review.objects.create( buyer = buyer, product = product, comments = comment, ratings = int(ratings), ) reviews = Review.objects.filter(product = product_id) for order in reviews: buyers = Buyer.objects.filter(id = order.buyer.id).annotate(ratings = Sum(order.ratings, output_field = IntegerField()), comments = Value(order.comments, output_field = CharField()), created_at = Value(order.created_at, output_field = DateTimeField())).first() review.append(buyers) data = ReviewSerializer(review, many=True) return Response(data.data, status=status.HTTP_200_OK)
def getBuyerOrders(request): # print(request.META['HTTP_AUTHORIZATION']) products = [] r_token = request.META['HTTP_AUTHORIZATION'] new_token = r_token.split(' ', 1)[1] token = Token.objects.filter(key=new_token).first() buyer = Buyer.objects.filter(user_ptr_id=token.user.id).first() if not buyer: return Response( data={ "Message": "You are not logged in" }, status=status.HTTP_400_BAD_REQUEST ) wishlistProducts = Wishlist.objects.filter(buyer=buyer) for order in wishlistProducts: allwishlistproducts = Product.objects.filter(id = order.product.id).annotate(wishlist_id=Sum(order.id, output_field=IntegerField())).first() products.append(allwishlistproducts) data = CustomWishlistSerializer(products, many=True) context = { 'data': data.data } return Response(data.data,status=status.HTTP_200_OK)
def getReview(request, product_id): review = [] reviews = Review.objects.filter(product = product_id) for order in reviews: buyers = Buyer.objects.filter(id = order.buyer.id).annotate(ratings = Sum(order.ratings, output_field = IntegerField()), comments = Value(order.comments, output_field = CharField()), created_at = Value(order.created_at, output_field = DateTimeField())).first() review.append(buyers) data = ReviewSerializer(review, many=True) return Response(data.data, status=status.HTTP_200_OK)
def getvariantoptions(request, product_id): variants = [] variant_option = Product_Variant_Options.objects.filter(product = product_id) for order in variant_option: parent_variant = Variant_Option.objects.filter(id=order.variant_options.id) for order2 in parent_variant: variant = Variant.objects.filter(id=order2.variant.id).annotate(variant_option_id = Sum(order2.id, output_field = IntegerField()), variant_option_name = Value(order2.name, output_field = CharField())).first() variants.append(variant) data = CustomVariantsSerializer(variants, many=True) context = { 'data': data.data } return Response(data.data,status=status.HTTP_200_OK)
def addtowishlist(request, product_id): # print(request.META['HTTP_AUTHORIZATION']) products = [] r_token = request.META['HTTP_AUTHORIZATION'] new_token = r_token.split(' ', 1)[1] product = Product.objects.filter(id=product_id).first() token = Token.objects.filter(key=new_token).first() buyer = Buyer.objects.filter(user_ptr_id=token.user.id).first() if not product_id: return Response( data={ "Message": "Product does not exist" }, status=status.HTTP_400_BAD_REQUEST ) if Wishlist.objects.filter(buyer = buyer, product = product).exists(): return Response( data={ "Message": "Product already in wishlist" }, status=status.HTTP_400_BAD_REQUEST ) new_wishlistProduct = Wishlist.objects.create( product=product, buyer=buyer, ) productID = Wishlist.objects.filter(buyer=buyer) for order in productID: Wishlist_product = Product.objects.filter(id = order.product.id).annotate(wishlist_id=Sum(order.id, output_field=IntegerField())).first() products.append(Wishlist_product) data = CustomWishlistSerializer(products, many=True) context = { 'data': data.data } return Response(data.data,status=status.HTTP_201_CREATED)
class UsedItem(SoftDeletionModel): item = ForeignKey(Item, on_delete=models.CASCADE) quantity = IntegerField()
class Interaction(LastModifiedModel): class Synergy(IntegerChoices): UNKNOWN = (0, "Inconnue") NEUTRAL = (1, "Neutre") ADDITIVE = (5, "Addition") DECREASE = (2, "Atténuation") INCREASE = (3, "Potentialisation") MIXED = (4, "Mixte") class Risk(IntegerChoices): UNKNOWN = (0, "Inconnu") NEUTRAL = (1, "Neutre") CAUTION = (2, "Vigilance") UNSAFE = (3, "Risqué") DANGEROUS = (4, "Dangereux") class Reliability(IntegerChoices): UNKNOWN = (0, "Non évaluée") HYPOTHETICAL = (1, "Théorique") INFERRED = (2, "Supposée") PROVEN = (3, "Avérée") from_drug = ForeignKey('Drug', CASCADE, related_name='interactions_from', verbose_name="première substance") to_drug = ForeignKey('Drug', CASCADE, related_name='interactions_to', verbose_name="seconde substance") risk = IntegerField(choices=Risk.choices, default=Risk.UNKNOWN, verbose_name="risques") synergy = IntegerField(choices=Synergy.choices, default=Synergy.UNKNOWN, verbose_name="synergie") risk_reliability = IntegerField(choices=Reliability.choices, default=Reliability.UNKNOWN, verbose_name="fiabilité des risques") effects_reliability = IntegerField( choices=Reliability.choices, default=Reliability.UNKNOWN, verbose_name="fiabilité de la synergie et des effets") risk_description = TextField(default='', blank=True, verbose_name="description des risques", help_text=markdown_allowed()) effect_description = TextField(default='', blank=True, verbose_name="description des effets", help_text=markdown_allowed()) notes = TextField( default='', blank=True, verbose_name="notes", help_text="Ce champ n'est visible que sur ce site " \ "d'administration et est partagé entre tous les " \ "utilisateurs." ) is_draft = BooleanField( default=True, verbose_name="brouillon", help_text="En cas de travail en cours, de données incertaines" \ " ou incomplètes." ) history = HistoricalRecords() objects = InteractionManager() def __str__(self): return f"{self.from_drug.name} + {self.to_drug.name}" def get_absolute_url(self): return reverse( 'combine', kwargs={'slugs': (self.from_drug.slug, self.to_drug.slug)}) def other_interactant(self, drug): index = self.interactants.index(drug) return self.interactants[not index] def get_contrib_email_body(self): return render_to_string('drugcombinator/mail/contrib_body.txt', {'interaction': self}) @property def interactants(self): return (self.from_drug, self.to_drug) @interactants.setter def interactants(self, interactants): interactants = sorted(interactants, key=attrgetter('name')) self.from_drug, self.to_drug = interactants def sort_interactants(self): # The interactants property setter will handle interactants # reordering self.interactants = self.interactants def save(self, *args, **kwargs): self.sort_interactants() super().save(*args, **kwargs) @classmethod def get_dummy_risks(cls): return [cls(risk=risk) for risk in cls.Risk.values] @classmethod def get_dummy_synergies(cls): return [cls(synergy=synergy) for synergy in cls.Synergy.values] class Meta: constraints = (CheckConstraint(check=~Q(from_drug=F('to_drug')), name='interactants_inequals'), UniqueConstraint(fields=('from_drug', 'to_drug'), name='interactants_unique_together')) verbose_name = "interaction"
def get_other_units(unit): """Returns other units to show while translating.""" result = { "total": 0, "skipped": False, "same": [], "matching": [], "context": [], "source": [], } allow_merge = False untranslated = False translation = unit.translation component = translation.component propagation = component.allow_translation_propagation same = None if unit.source and unit.context: match = Q(source=unit.source) & Q(context=unit.context) if component.has_template(): query = Q(source=unit.source) | Q(context=unit.context) else: query = Q(source=unit.source) elif unit.source: match = Q(source=unit.source) & Q(context="") query = Q(source=unit.source) elif unit.context: match = Q(context=unit.context) query = Q(context=unit.context) else: return result units = (Unit.objects.filter( query, translation__component__project=component.project, translation__language=translation.language, ).annotate(matches_current=Case( When(condition=match, then=1), default=0, output_field=IntegerField())).order_by("-matches_current")) units_count = units.count() # Is it only this unit? if units_count == 1: return result result["total"] = units_count result["skipped"] = units_count > 20 for item in units[:20]: item.allow_merge = item.differently_translated = ( item.translated and item.target != unit.target) item.is_propagated = ( propagation and item.translation.component.allow_translation_propagation and item.translation.plural_id == translation.plural_id and item.source == unit.source and item.context == unit.context) untranslated |= not item.translated allow_merge |= item.allow_merge if item.pk == unit.pk: same = item result["same"].append(item) elif item.source == unit.source and item.context == unit.context: result["matching"].append(item) elif item.source == unit.source: result["source"].append(item) elif item.context == unit.context: result["context"].append(item) # Slightly different logic to allow applying current translation to # the propagated strings if same is not None: same.allow_merge = ((untranslated or allow_merge) and same.translated and propagation) allow_merge |= same.allow_merge result["total"] = sum( len(result[x]) for x in ("matching", "source", "context")) result["allow_merge"] = allow_merge return result
def test_trunc_func(self): start_datetime = microsecond_support(datetime(2015, 6, 15, 14, 30, 50, 321)) end_datetime = microsecond_support(datetime(2016, 6, 15, 14, 10, 50, 123)) if settings.USE_TZ: start_datetime = timezone.make_aware(start_datetime, is_dst=False) end_datetime = timezone.make_aware(end_datetime, is_dst=False) self.create_model(start_datetime, end_datetime) self.create_model(end_datetime, start_datetime) msg = 'output_field must be either DateField, TimeField, or DateTimeField' with self.assertRaisesMessage(ValueError, msg): list(DTModel.objects.annotate(truncated=Trunc('start_datetime', 'year', output_field=IntegerField()))) with self.assertRaisesMessage(AssertionError, "'name' isn't a DateField, TimeField, or DateTimeField."): list(DTModel.objects.annotate(truncated=Trunc('name', 'year', output_field=DateTimeField()))) with self.assertRaisesMessage(ValueError, "Cannot truncate DateField 'start_date' to DateTimeField"): list(DTModel.objects.annotate(truncated=Trunc('start_date', 'second'))) with self.assertRaisesMessage(ValueError, "Cannot truncate TimeField 'start_time' to DateTimeField"): list(DTModel.objects.annotate(truncated=Trunc('start_time', 'month'))) with self.assertRaisesMessage(ValueError, "Cannot truncate DateField 'start_date' to DateTimeField"): list(DTModel.objects.annotate(truncated=Trunc('start_date', 'month', output_field=DateTimeField()))) with self.assertRaisesMessage(ValueError, "Cannot truncate TimeField 'start_time' to DateTimeField"): list(DTModel.objects.annotate(truncated=Trunc('start_time', 'second', output_field=DateTimeField()))) def test_datetime_kind(kind): self.assertQuerysetEqual( DTModel.objects.annotate( truncated=Trunc('start_datetime', kind, output_field=DateTimeField()) ).order_by('start_datetime'), [ (truncate_to(start_datetime, kind)), (truncate_to(end_datetime, kind)) ], lambda m: (m.truncated) ) def test_date_kind(kind): self.assertQuerysetEqual( DTModel.objects.annotate( truncated=Trunc('start_date', kind, output_field=DateField()) ).order_by('start_datetime'), [ (truncate_to(start_datetime.date(), kind)), (truncate_to(end_datetime.date(), kind)) ], lambda m: (m.truncated) ) def test_time_kind(kind): self.assertQuerysetEqual( DTModel.objects.annotate( truncated=Trunc('start_time', kind, output_field=TimeField()) ).order_by('start_datetime'), [ (truncate_to(start_datetime.time(), kind)), (truncate_to(end_datetime.time(), kind)) ], lambda m: (m.truncated) ) test_date_kind('year') test_date_kind('month') test_date_kind('day') test_time_kind('hour') test_time_kind('minute') test_time_kind('second') test_datetime_kind('year') test_datetime_kind('month') test_datetime_kind('day') test_datetime_kind('hour') test_datetime_kind('minute') test_datetime_kind('second') qs = DTModel.objects.filter(start_datetime__date=Trunc('start_datetime', 'day', output_field=DateField())) self.assertEqual(qs.count(), 2)
class EquipmentInstanceProblemDiagnosis(Model): """Equipment Instance Problem Diagnosis.""" RELATED_NAME = 'equipment_instance_problem_diagnoses' RELATED_QUERY_NAME = 'equipment_instance_problem_diagnosis' equipment_instance = \ ForeignKey( to=EquipmentInstance, related_name=RELATED_NAME, related_query_name=RELATED_QUERY_NAME, blank=False, null=False, on_delete=PROTECT) from_date = \ DateField( blank=False, null=False, db_index=True) to_date = \ DateField( blank=True, null=True, db_index=True) date_range = \ DateRangeField( blank=True, null=True) duration = \ IntegerField( blank=True, null=True) equipment_problem_types = \ ManyToManyField( to=EquipmentProblemType, related_name=RELATED_NAME, related_query_name=RELATED_QUERY_NAME, blank=True) has_equipment_problems = \ BooleanField( blank=False, null=False, default=False, db_index=True) dismissed = \ BooleanField( blank=False, null=False, default=False, db_index=True) comments = \ TextField( blank=True, null=True) equipment_instance_alarm_periods = \ ManyToManyField( to=EquipmentInstanceAlarmPeriod, through=(EquipmentInstanceAlarmPeriod .equipment_instance_problem_diagnoses.through), related_name=RELATED_NAME + '_reverse', related_query_name=RELATED_QUERY_NAME, blank=True) has_associated_equipment_instance_alarm_periods = \ BooleanField( blank=False, null=False, default=False, db_index=True) equipment_instance_alert_periods = \ ManyToManyField( to='EquipmentInstanceAlertPeriod', related_name=RELATED_NAME + '_reverse', related_query_name=RELATED_QUERY_NAME, blank=True) has_associated_equipment_instance_alert_periods = \ BooleanField( blank=False, null=False, default=False, db_index=True) class Meta: """Metadata.""" verbose_name = 'Equipment Instance Problem Diagnosis' verbose_name_plural = 'Equipment Instance Problem Diagnoses' unique_together = 'equipment_instance', 'from_date' ordering = 'dismissed', '-to_date', 'from_date' def __str__(self): """Return string repr.""" return (f'{self.equipment_instance} from {self.from_date} ' + (f'to {self.to_date}' if self.to_date else '(ONGOING)') + ( ': {}'.format( # pylint: disable=consider-using-f-string ', '.join(equipment_problem_type.name.upper() for equipment_problem_type in self.equipment_problem_types.all())) if self.equipment_problem_types.count() else '') + (' (DISMISSED)' if self.dismissed else '')) def save(self, *args, **kwargs): """Save.""" self.date_range = \ DateRange( lower=self.from_date, upper=self.to_date, bounds='[]', empty=False) self.duration = \ (self.to_date - self.from_date).days + 1 \ if self.to_date \ else None super().save(*args, **kwargs)
def get_grouped_items(event, subevent=None, voucher=None, channel='web', require_seat=0, base_qs=None, allow_addons=False, quota_cache=None, filter_items=None, filter_categories=None): base_qs_set = base_qs is not None base_qs = base_qs if base_qs is not None else event.items requires_seat = Exists( SeatCategoryMapping.objects.filter(product_id=OuterRef('pk'), subevent=subevent)) if not event.settings.seating_choice: requires_seat = Value(0, output_field=IntegerField()) items = base_qs.using(settings.DATABASE_REPLICA).filter_available( channel=channel, voucher=voucher, allow_addons=allow_addons).select_related( 'category', 'tax_rule', # for re-grouping 'hidden_if_available', ).prefetch_related( Prefetch('quotas', to_attr='_subevent_quotas', queryset=event.quotas.using( settings.DATABASE_REPLICA).filter(subevent=subevent)), Prefetch( 'bundles', queryset=ItemBundle.objects.using( settings.DATABASE_REPLICA).prefetch_related( Prefetch('bundled_item', queryset=event.items.using( settings.DATABASE_REPLICA). select_related('tax_rule').prefetch_related( Prefetch( 'quotas', to_attr='_subevent_quotas', queryset=event.quotas.using( settings.DATABASE_REPLICA).filter( subevent=subevent)), )), Prefetch( 'bundled_variation', queryset=ItemVariation.objects.using( settings.DATABASE_REPLICA).select_related( 'item', 'item__tax_rule'). filter(item__event=event).prefetch_related( Prefetch('quotas', to_attr='_subevent_quotas', queryset=event.quotas.using( settings.DATABASE_REPLICA).filter( subevent=subevent)), )), )), Prefetch('variations', to_attr='available_variations', queryset=ItemVariation.objects.using( settings.DATABASE_REPLICA).annotate( subevent_disabled=Exists( SubEventItemVariation.objects.filter( variation_id=OuterRef('pk'), subevent=subevent, disabled=True, )), ).filter(active=True, quotas__isnull=False, subevent_disabled=False). prefetch_related( Prefetch('quotas', to_attr='_subevent_quotas', queryset=event.quotas.using( settings.DATABASE_REPLICA).filter( subevent=subevent))).distinct()), ).annotate( quotac=Count('quotas'), has_variations=Count('variations'), subevent_disabled=Exists( SubEventItem.objects.filter( item_id=OuterRef('pk'), subevent=subevent, disabled=True, )), requires_seat=requires_seat, ).filter( quotac__gt=0, subevent_disabled=False, ).order_by('category__position', 'category_id', 'position', 'name') if require_seat: items = items.filter(requires_seat__gt=0) else: items = items.filter(requires_seat=0) if filter_items: items = items.filter(pk__in=[a for a in filter_items if a.isdigit()]) if filter_categories: items = items.filter( category_id__in=[a for a in filter_categories if a.isdigit()]) display_add_to_cart = False quota_cache_key = f'item_quota_cache:{subevent.id if subevent else 0}:{channel}:{bool(require_seat)}' quota_cache = quota_cache or event.cache.get(quota_cache_key) or {} quota_cache_existed = bool(quota_cache) if subevent: item_price_override = subevent.item_price_overrides var_price_override = subevent.var_price_overrides else: item_price_override = {} var_price_override = {} restrict_vars = set() if voucher and voucher.quota_id: # If a voucher is set to a specific quota, we need to filter out on that level restrict_vars = set(voucher.quota.variations.all()) quotas_to_compute = [] for item in items: if item.has_variations: for v in item.available_variations: for q in v._subevent_quotas: if q.pk not in quota_cache: quotas_to_compute.append(q) else: for q in item._subevent_quotas: if q.pk not in quota_cache: quotas_to_compute.append(q) if quotas_to_compute: qa = QuotaAvailability() qa.queue(*quotas_to_compute) qa.compute() quota_cache.update({q.pk: r for q, r in qa.results.items()}) for item in items: if voucher and voucher.item_id and voucher.variation_id: # Restrict variations if the voucher only allows one item.available_variations = [ v for v in item.available_variations if v.pk == voucher.variation_id ] if get_all_sales_channels()[channel].unlimited_items_per_order: max_per_order = sys.maxsize else: max_per_order = item.max_per_order or int( event.settings.max_items_per_order) if item.hidden_if_available: q = item.hidden_if_available.availability(_cache=quota_cache) if q[0] == Quota.AVAILABILITY_OK: item._remove = True continue item.description = str(item.description) for recv, resp in item_description.send(sender=event, item=item, variation=None): if resp: item.description += ("<br/>" if item.description else "") + resp if not item.has_variations: item._remove = False if not bool(item._subevent_quotas): item._remove = True continue if voucher and (voucher.allow_ignore_quota or voucher.block_quota): item.cached_availability = (Quota.AVAILABILITY_OK, voucher.max_usages - voucher.redeemed) else: item.cached_availability = list( item.check_quotas(subevent=subevent, _cache=quota_cache, include_bundled=True)) if event.settings.hide_sold_out and item.cached_availability[ 0] < Quota.AVAILABILITY_RESERVED: item._remove = True continue item.order_max = min( item.cached_availability[1] if item.cached_availability[1] is not None else sys.maxsize, max_per_order) original_price = item_price_override.get(item.pk, item.default_price) if voucher: price = voucher.calculate_price(original_price) else: price = original_price item.display_price = item.tax(price, currency=event.currency, include_bundled=True) if price != original_price: item.original_price = item.tax(original_price, currency=event.currency, include_bundled=True) else: item.original_price = ( item.tax(item.original_price, currency=event.currency, include_bundled=True, base_price_is='net' if event.settings.display_net_prices else 'gross') # backwards-compat if item.original_price else None) display_add_to_cart = display_add_to_cart or item.order_max > 0 else: for var in item.available_variations: var.description = str(var.description) for recv, resp in item_description.send(sender=event, item=item, variation=var): if resp: var.description += ("<br/>" if var.description else "") + resp if voucher and (voucher.allow_ignore_quota or voucher.block_quota): var.cached_availability = (Quota.AVAILABILITY_OK, voucher.max_usages - voucher.redeemed) else: var.cached_availability = list( var.check_quotas(subevent=subevent, _cache=quota_cache, include_bundled=True)) var.order_max = min( var.cached_availability[1] if var.cached_availability[1] is not None else sys.maxsize, max_per_order) original_price = var_price_override.get(var.pk, var.price) if voucher: price = voucher.calculate_price(original_price) else: price = original_price var.display_price = var.tax(price, currency=event.currency, include_bundled=True) if price != original_price: var.original_price = var.tax(original_price, currency=event.currency, include_bundled=True) else: var.original_price = ( var.tax(var.original_price or item.original_price, currency=event.currency, include_bundled=True, base_price_is='net' if event.settings.display_net_prices else 'gross') # backwards-compat ) if var.original_price or item.original_price else None display_add_to_cart = display_add_to_cart or var.order_max > 0 item.original_price = ( item.tax( item.original_price, currency=event.currency, include_bundled=True, base_price_is='net' if event.settings.display_net_prices else 'gross') # backwards-compat if item.original_price else None) item.available_variations = [ v for v in item.available_variations if v._subevent_quotas and ( not voucher or not voucher.quota_id or v in restrict_vars) ] if event.settings.hide_sold_out: item.available_variations = [ v for v in item.available_variations if v.cached_availability[0] >= Quota.AVAILABILITY_RESERVED ] if voucher and voucher.variation_id: item.available_variations = [ v for v in item.available_variations if v.pk == voucher.variation_id ] if len(item.available_variations) > 0: item.min_price = min([ v.display_price.net if event.settings.display_net_prices else v.display_price.gross for v in item.available_variations ]) item.max_price = max([ v.display_price.net if event.settings.display_net_prices else v.display_price.gross for v in item.available_variations ]) item._remove = not bool(item.available_variations) if not quota_cache_existed and not voucher and not allow_addons and not base_qs_set and not filter_items and not filter_categories: event.cache.set(quota_cache_key, quota_cache, 5) items = [ item for item in items if (len(item.available_variations) > 0 or not item.has_variations) and not item._remove ] return items, display_add_to_cart
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) if not (self.object.ended or self.can_edit): raise Http404() queryset = Submission.objects.filter(contest_object=self.object) ac_count = Count( Case(When(result='AC', then=Value(1)), output_field=IntegerField())) ac_rate = CombinedExpression(ac_count / Count('problem'), '*', Value(100.0), output_field=FloatField()) status_count_queryset = list( queryset.values('problem__code', 'result').annotate( count=Count('result')).values_list('problem__code', 'result', 'count'), ) labels, codes = [], [] contest_problems = self.object.contest_problems.order_by( 'order').values_list('problem__name', 'problem__code') if contest_problems: labels, codes = zip(*contest_problems) num_problems = len(labels) status_counts = [[] for i in range(num_problems)] for problem_code, result, count in status_count_queryset: if problem_code in codes: status_counts[codes.index(problem_code)].append( (result, count)) result_data = defaultdict(partial(list, [0] * num_problems)) for i in range(num_problems): for category in _get_result_data(defaultdict( int, status_counts[i]))['categories']: result_data[category['code']][i] = category['count'] stats = { 'problem_status_count': { 'labels': labels, 'datasets': [{ 'label': name, 'backgroundColor': settings.DMOJ_STATS_SUBMISSION_RESULT_COLORS[name], 'data': data, } for name, data in result_data.items()], }, 'problem_ac_rate': get_bar_chart( queryset.values( 'contest__problem__order', 'problem__name').annotate(ac_rate=ac_rate).order_by( 'contest__problem__order').values_list( 'problem__name', 'ac_rate'), ), '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'), ), 'language_ac_rate': get_bar_chart( queryset.values('language__name').annotate( ac_rate=ac_rate).filter(ac_rate__gt=0).values_list( 'language__name', 'ac_rate'), ), } context['stats'] = mark_safe(json.dumps(stats)) return context
class ROILink(Model): user = ForeignKey(Profile) link = URLField() label = CharField(max_length=256) uuid = UUIDField(default=uuid4) visits = IntegerField(default=0)
class RunningJob(Model): job = ForeignKey('Job', blank=False, on_delete=PROTECT) node = ForeignKey(Node, blank=False, on_delete=PROTECT) core_num = IntegerField(null=False, blank=False) gpu_num = IntegerField(null=False, blank=False)
class CourseProgress(Model): user = ForeignKey(User, CASCADE) course = ForeignKey(Course, CASCADE) percent_complete = IntegerField()
class Script(CleanSave, TimestampedModel): # Force model into the metadataserver namespace. class Meta(DefaultMeta): pass objects = ScriptManager() name = CharField(max_length=255, unique=True) title = CharField(max_length=255, blank=True) description = TextField(blank=True) tags = ArrayField(TextField(), blank=True, null=True, default=list) script_type = IntegerField(choices=SCRIPT_TYPE_CHOICES, default=SCRIPT_TYPE.TESTING) # The hardware the script configures or tests. hardware_type = IntegerField(choices=HARDWARE_TYPE_CHOICES, default=HARDWARE_TYPE.NODE) # Whether the script can run in parallel with other scripts. parallel = IntegerField(choices=SCRIPT_PARALLEL_CHOICES, default=SCRIPT_PARALLEL.DISABLED) # Any results which will be made availble after the script is run. results = JSONObjectField(blank=True, default={}) # Parameters which may be passed to the script and their constraints. parameters = JSONObjectField(blank=True, default={}) # apt, snap, dpkg, to install or archives to extract. packages = JSONObjectField(blank=True, default={}) # 0 is no timeout timeout = DurationField(default=datetime.timedelta()) destructive = BooleanField(default=False) # True only if the script is shipped with MAAS default = BooleanField(default=False) script = OneToOneField(VersionedTextFile, on_delete=CASCADE) # A list of hardware identifiers(modalias, PCI id, USB id, or name) this # script is applicable to. This script will always run on machines with # matching hardware. for_hardware = ArrayField(CharField(max_length=255), blank=True, default=list) # Whether or not the script may reboot while running. Tells the status # monitor to wait until NODE_FAILURE_MONITORED_STATUS_TIMEOUTS before # timing out. may_reboot = BooleanField(default=False) # Only applicable to commissioning scripts. When true reruns commissioning # scripts after receiving the result. recommission = BooleanField(default=False) # Whether or not maas-run-remote-scripts should apply user configured # network settings before running the Script. apply_configured_networking = BooleanField(default=False) @property def ForHardware(self): """Parses the for_hardware field and returns a ForHardware tuple.""" modaliases = [] pci = [] usb = [] for descriptor in self.for_hardware: try: hwtype, value = descriptor.split(":", 1) except ValueError: continue if hwtype == "modalias": modaliases.append(value) elif hwtype == "pci": pci.append(value) elif hwtype == "usb": usb.append(value) return ForHardware(modaliases, pci, usb) @property def script_type_name(self): for script_type, script_type_name in SCRIPT_TYPE_CHOICES: if self.script_type == script_type: return script_type_name return "unknown" @property def hardware_type_name(self): return HARDWARE_TYPE_CHOICES[self.hardware_type][1] @property def parallel_name(self): return SCRIPT_PARALLEL_CHOICES[self.parallel][1] def __str__(self): return self.name def add_tag(self, tag): """Add tag to Script.""" if tag not in self.tags: self.tags = self.tags + [tag] def remove_tag(self, tag): """Remove tag from Script.""" if tag in self.tags: tags = self.tags.copy() tags.remove(tag) self.tags = tags def save(self, *args, **kwargs): if self.destructive: self.add_tag("destructive") else: self.remove_tag("destructive") for hw_type, hw_type_label in HARDWARE_TYPE_CHOICES: if hw_type == self.hardware_type: self.add_tag(hw_type_label.lower()) else: self.remove_tag(hw_type_label.lower()) return super().save(*args, **kwargs)
def __init__(self, expression, output_field=None, **extra): if output_field is None: output_field = IntegerField() super(ExtractDay, self).__init__(expression, output_field=output_field, **extra)
def output_field(self): return IntegerField()
class BootResource(CleanSave, TimestampedModel): """Boot resource. Each `BootResource` represents a os/series combination or custom uploaded image that maps to a specific architecture that a node can use to commission or install. `BootResource` can have multiple `BootResourceSet` corresponding to different versions of this `BootResource`. When a node selects this `BootResource` the newest `BootResourceSet` is used to deploy to the node. :ivar rtype: Type of `BootResource`. See the vocabulary :class:`BOOT_RESOURCE_TYPE`. :ivar name: Name of the `BootResource`. If its BOOT_RESOURCE_TYPE.UPLOADED then `name` is used to reference this image. If its BOOT_RESOURCE_TYPE.SYCNED or BOOT_RESOURCE_TYPE.GENERATED then its in the format of os/series. :ivar architecture: Architecture of the `BootResource`. It must be in the format arch/subarch. :ivar extra: Extra information about the file. This is only used for synced Ubuntu images. """ class Meta(DefaultMeta): unique_together = (("name", "architecture"), ) objects = BootResourceManager() rtype = IntegerField(choices=BOOT_RESOURCE_TYPE_CHOICES, editable=False) name = CharField(max_length=255, blank=False) architecture = CharField(max_length=255, blank=False, validators=[validate_architecture]) bootloader_type = CharField(max_length=32, blank=True, null=True) kflavor = CharField(max_length=32, blank=True, null=True) # The hwe-rolling kernel is a meta-package which depends on the latest # kernel available. Instead of placing a duplicate kernel in the stream # SimpleStreams adds a boolean field to indicate that the hwe-rolling # kernel meta-package points to this kernel. When the rolling field is set # true MAAS allows users to deploy the hwe-rolling kernel by using this # BootResource kernel and instructs Curtin to install the meta-package. rolling = BooleanField(blank=False, null=False, default=False) extra = JSONObjectField(blank=True, default="", editable=False) def __str__(self): return "<BootResource name=%s, arch=%s, kflavor=%s>" % ( self.name, self.architecture, self.kflavor, ) @property def display_rtype(self): """Return rtype text as displayed to the user.""" return BOOT_RESOURCE_TYPE_CHOICES_DICT[self.rtype] def clean(self): """Validate the model. Checks that the name is in a valid format, for its type. """ if self.rtype == BOOT_RESOURCE_TYPE.UPLOADED: if "/" in self.name: os_name = self.name.split("/")[0] osystem = OperatingSystemRegistry.get_item(os_name) if osystem is None: raise ValidationError( "%s boot resource cannot contain a '/' in it's name " "unless it starts with a supported operating system." % (self.display_rtype)) elif self.rtype in RTYPE_REQUIRING_OS_SERIES_NAME: if "/" not in self.name: raise ValidationError( "%s boot resource must contain a '/' in it's name." % (self.display_rtype)) def unique_error_message(self, model_class, unique_check): if unique_check == ("name", "architecture"): return "Boot resource of name, and architecture already exists." return super().unique_error_message(model_class, unique_check) def get_latest_set(self): """Return latest `BootResourceSet`.""" if (not hasattr(self, "_prefetched_objects_cache") or "sets" not in self._prefetched_objects_cache): return self.sets.order_by("id").last() elif self.sets.all(): return sorted(self.sets.all(), key=attrgetter("id"), reverse=True)[0] else: return None def get_latest_complete_set(self): """Return latest `BootResourceSet` where all `BootResouceFile`'s are complete.""" if (not hasattr(self, "_prefetched_objects_cache") or "sets" not in self._prefetched_objects_cache): resource_sets = self.sets.order_by("-id").annotate( files_count=Count("files__id"), files_size=Sum("files__largefile__size"), files_total_size=Sum("files__largefile__total_size"), ) else: resource_sets = sorted(self.sets.all(), key=attrgetter("id"), reverse=True) for resource_set in resource_sets: if (resource_set.files_count > 0 and resource_set.files_size == resource_set.files_total_size): return resource_set return None def split_arch(self): return self.architecture.split("/") def get_next_version_name(self): """Return the version a `BootResourceSet` should use when adding to this resource. The version naming is specific to how the resource sets will be sorted by simplestreams. The version name is YYYYmmdd, with an optional revision index. (e.g. 20140822.1) This method gets the current date, and checks if a revision already exists in the database. If it doesn't then just the current date is returned. If it does exists then the next revision in the set for that date will be returned. :return: Name of version to use for a new set on this `BootResource`. :rtype: string """ version_name = now().strftime("%Y%m%d") sets = self.sets.filter( version__startswith=version_name).order_by("version") if not sets.exists(): return version_name max_idx = 0 for resource_set in sets: if "." in resource_set.version: _, set_idx = resource_set.version.split(".") set_idx = int(set_idx) if set_idx > max_idx: max_idx = set_idx return "%s.%d" % (version_name, max_idx + 1) def supports_subarch(self, subarch): """Return True if the resource supports the given subarch.""" _, self_subarch = self.split_arch() if subarch == self_subarch: return True if "subarches" not in self.extra: return False subarches = self.extra["subarches"].split(",") return subarch in subarches
class Topic(BasePage): resource_type = "topic" parent_page_types = ["Topics"] subpage_types = ["Topic"] template = "topic.html" # Content fields description = RichTextField( blank=True, default="", features=RICH_TEXT_FEATURES_SIMPLE, help_text="Optional short text description, max. 400 characters", max_length=400, ) featured = StreamField( StreamBlock( [ ( "article", PageChooserBlock(target_model=( "articles.Article", "externalcontent.ExternalArticle", )), ), ("external_page", FeaturedExternalBlock()), ], max_num=4, required=False, ), null=True, blank=True, help_text="Optional space for featured articles, max. 4", ) tabbed_panels = StreamField( StreamBlock([("panel", TabbedPanelBlock())], max_num=3, required=False), null=True, blank=True, help_text= "Optional tabbed panels for linking out to other resources, max. 3", verbose_name="Tabbed panels", ) latest_articles_count = IntegerField( choices=RESOURCE_COUNT_CHOICES, default=3, help_text="The number of articles to display for this topic.", ) # Card fields card_title = CharField("Title", max_length=140, blank=True, default="") card_description = TextField("Description", max_length=400, blank=True, default="") card_image = ForeignKey( "mozimages.MozImage", null=True, blank=True, on_delete=SET_NULL, related_name="+", verbose_name="Image", ) # Meta icon = FileField(upload_to="topics/icons", blank=True, default="") color = CharField(max_length=14, choices=COLOR_CHOICES, default="blue-40") keywords = ClusterTaggableManager(through=TopicTag, blank=True) # Content panels content_panels = BasePage.content_panels + [ FieldPanel("description"), StreamFieldPanel("featured"), StreamFieldPanel("tabbed_panels"), FieldPanel("latest_articles_count"), MultiFieldPanel( [InlinePanel("people")], heading="People", help_text= "Optional list of people associated with this topic as experts", ), ] # Card panels card_panels = [ FieldPanel("card_title"), FieldPanel("card_description"), ImageChooserPanel("card_image"), ] # Meta panels meta_panels = [ MultiFieldPanel( [ InlinePanel("parent_topics", label="Parent topic(s)"), InlinePanel("child_topics", label="Child topic(s)"), ], heading="Parent/child topic(s)", classname="collapsible collapsed", help_text=("Topics with no parent (i.e. top-level topics) will be " "listed on the home page. Child topics are listed " "on the parent topic’s page."), ), MultiFieldPanel( [FieldPanel("icon"), FieldPanel("color")], heading="Theme", help_text=( "Theme settings used on topic page and any tagged content. " "For example, an article tagged with this topic " "will use the color specified here as its accent color."), ), MultiFieldPanel( [ FieldPanel("seo_title"), FieldPanel("search_description"), ImageChooserPanel("social_image"), FieldPanel("keywords"), ], heading="SEO", help_text=("Optional fields to override the default " "title and description for SEO purposes"), ), ] # Settings panels settings_panels = [FieldPanel("slug"), FieldPanel("show_in_menus")] # Tabs edit_handler = TabbedInterface([ ObjectList(content_panels, heading="Content"), ObjectList(card_panels, heading="Card"), ObjectList(meta_panels, heading="Meta"), ObjectList(settings_panels, heading="Settings", classname="settings"), ]) @property def articles(self): return get_combined_articles(self, topics__topic__pk=self.pk) @property def events(self): """Return upcoming events for this topic, ignoring events in the past, ordered by start date""" return get_combined_events(self, topics__topic__pk=self.pk, start_date__gte=datetime.datetime.now()) @property def experts(self): """Return Person instances for topic experts""" return [person.person for person in self.people.all()] @property def videos(self): """Return the latest videos and external videos for this topic. """ return get_combined_videos(self, topics__topic__pk=self.pk) @property def color_value(self): return dict(COLOR_VALUES)[self.color] @property def subtopics(self): return [topic.child for topic in self.child_topics.all()]
def updatecart(request, order_id): print(order_id) current_orderproduct = Order_Product.objects.filter(id = order_id).first() quantity = request.data.get("quantity",) product = Product.objects.filter(id =current_orderproduct.product.id).first() amount = product.unit_cost if not quantity: return Response( data={ "Message": "Make Sure All The Fields Are Included" }, status=status.HTTP_400_BAD_REQUEST ) current_orderproduct.quantity = quantity current_orderproduct.total = float(amount)*float(quantity) current_orderproduct.save() products = [] r_token = request.META['HTTP_AUTHORIZATION'] new_token = r_token.split(' ', 1)[1] token = Token.objects.filter(key=new_token).first() buyer = Buyer.objects.filter(user_ptr_id=token.user.id).first() cart_items = Order_Product.objects.filter(buyer=buyer, checkout__isnull=True) for order in cart_items: if order.quantity is not None: print(order.quantity) product = Product.objects.filter(id=order.product.id).annotate(order_id=Sum(order.id, output_field=IntegerField()),quantity=Sum(order.quantity, output_field=FloatField()), total=Sum(order.total, output_field=FloatField())).first() print(product.quantity) products.append(product) data = CustomCartSerializer(products, many=True) context = { 'data': data.data } return Response(data.data,status=status.HTTP_200_OK)