def post_user_info(req): user_name = req.POST.get('user_name') user = User(userName=user) user.save() id = models.QuerySet(User).all().aggregate(Max('id')) id = id['id__max'] user = models.QuerySet(User).get(id=id) runking = Runking(User=user) return HttpResponse(id)
def post_tag_info(req): image_idx = int(req.POST.get('image_idx')) image_correct = int(req.POST.get('correct')) user_id = int(req.POST.get('id')) image_obj = models.QuerySet(Image_list).filter(id=image_idx).first() image_obj.correct = image_correct image_obj.save() user = models.QuerySet(User).get(id=user_id) runking = models.QuerySet(Runking).filter(User=user).first() runking.point += 1 return HttpResponse('image info update')
def get_subfolders(self, current_level): raise NotImplementedError('Use MPTT for get_subfolders()') if current_level >= self.max_depth: return models.QuerySet() children = models.QuerySet(model=self.__class__) for child in sorted(self.children, key=lowername): children.append(child) children.extend(child.get_subfolders(current_level + 1)) return children
class Message(models.Model): name = models.CharField(max_length=255) phone = models.CharField(max_length=15) message = models.TextField() email = models.EmailField(null=True, blank=True) created_date = models.DateTimeField(auto_now_add=True) updated_date = models.DateTimeField(auto_now=True) history = HistoricalRecords() changed_by = models.ForeignKey(settings.AUTH_USER_MODEL, models.SET_NULL, null=True, blank=True) objects = models.QuerySet() class Meta: ordering = ['-created_date'] verbose_name = 'Message' @property def _history_user(self): return self.changed_by @_history_user.setter def _history_user(self, value): self.changed_by = value def __str__(self): return self.name + '-' + self.phone + '-' + self.message
class BloodInformation(models.Model): quetion = models.CharField(max_length=255) answer = models.TextField() created_date = models.DateTimeField(auto_now_add=True) updated_date = models.DateTimeField(auto_now=True) status = models.BooleanField( default=True, help_text='Want to published ?', ) history = HistoricalRecords() changed_by = models.ForeignKey(settings.AUTH_USER_MODEL, models.SET_NULL, null=True, blank=True) objects = models.QuerySet() class Meta: ordering = ['created_date'] verbose_name = 'Blood Related Quetions & Answer' @property def _history_user(self): return self.changed_by @_history_user.setter def _history_user(self, value): self.changed_by = value def __str__(self): return self.quetion + '-' + self.answer
def bulk_create(self, objs: Iterable[Instance], batch_size: Optional[int] = base_settings.DB_BATCH_SIZE, ignore_conflicts: bool = False) -> List[Instance]: self._for_write = True return models.QuerySet(self.model, using=self.db).bulk_create( objs, batch_size, ignore_conflicts)
def get_queryset(self): if self.active_only: return BookingSoftDeletionQuerySet( self.model).filter(cancelled_at=None) if self.cancelled_only: return models.QuerySet(self.model).exclude(cancelled_at=None) return BookingSoftDeletionQuerySet(self.model)
def get_queryset(self): queryset = models.QuerySet(self.model) if not self.inactive: queryset = queryset.filter(activatedOn__isnull=False) if not self.banned: queryset = queryset.filter(banned__isnull=True) return queryset
def none(self): c = models.QuerySet(model=self.model, query=self.query.chain(), using=self._db, hints=self._hints) c._sticky_filter = self._sticky_filter c._for_write = self._for_write c._prefetch_related_lookups = self._prefetch_related_lookups[:] c._known_related_objects = self._known_related_objects c._iterable_class = self._iterable_class c._fields = self._fields return c.none()
def test_naive_delete_is_permanent(self): ''' Assert that naive queryset deletes objects for good on bulk deletion. ''' indb = models.QuerySet(self.model) self.assertEqual(self.naive_qs.count(), 10) self.assertEqual(indb.count(), 10) self.naive_qs.delete() self.assertEqual(indb.count(), 0) self.assertEqual(self.naive_qs.count(), 0)
class ApplicationMonthlyPayment(models.Model): main_user = models.ForeignKey(MainUserProfile, on_delete=models.CASCADE, related_name="monthly_payments") _paid_time = models.DateTimeField() _next_pay = models.DateTimeField() objects = models.QuerySet() def __str__(self): return self.main_user
class MessageForm(forms.ModelForm): """Form definition for new Messages in the system.""" sender = forms.ModelChoiceField(queryset=models.QuerySet(UserProfile), to_field_name="username", label="From") receiver = forms.ModelChoiceField(queryset=models.QuerySet(UserProfile), to_field_name="username", label="To") subject = forms.CharField(label="Subject", validators=[validators.MinLengthValidator(0)]) message = forms.CharField(label="Message", widget=forms.Textarea, validators=[validators.MinLengthValidator(0)]) class Meta: """Meta definition for MessageForm.""" model = Message exclude = ["creation_date", "already_read"]
class InventoryFoodName(models.Model): UNIT_CHOICES = (('kg', 'KG'), ('ltr', 'LTR'), ('pcs', 'PCS')) user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='inventory_food_names') name = models.CharField(max_length=255) unit = models.CharField(choices=UNIT_CHOICES, max_length=5) objects = models.QuerySet() def __str__(self): return self.name
def test_default_delete(self): ''' Assert that shrewd queryset in its default mode deletes objects for good on bulk deletion. ''' qs = ShrewdQuerySet(self.model) indb = models.QuerySet(self.model) self.assertEqual(qs.count(), 8) self.assertEqual(indb.count(), 8) qs.delete() self.assertEqual(qs.count(), 0) self.assertEqual(indb.count(), 0)
def get_next_expression(self, model_instance): """ Generate an expression that will evaluate to the next valid ordering value """ # This will be the next number larger than existing records in the ordering set # If no records in the ordering set, start from 0 # Evade any custom model managers qs = models.QuerySet(self.model).filter( **self.get_filter_kwargs_for_object(model_instance)) qs = qs.annotate(_next=Max(self.attname) + 1).values('_next').order_by() # Hackishly clip group_by clause to guarantee single result qs.query.group_by = [] return BypassExpression( Coalesce(Subquery(qs), 0, output_field=models.IntegerField()))
def get_tag_list(req): cate = list(models.QuerySet(Cate).all().values_list('cate', flat=True)) idx = random.randrange(len(cate)) cate_selection = cate[idx] sub = list( models.QuerySet(Sub).filter(cate=cate_selection).values_list( 'sub', flat=True)) sub_selection = sub[random.randrange(len(sub))] taging_image_query = models.QuerySet(Image_list).filter(sub=sub_selection, correct__lt=0) taging_image = list(taging_image_query.values_list('image_path', flat=True)) taging_id = list(taging_image_query.values_list('id', flat=True)) if len(taging_image) < 10: n = len(taging_image) else: n = 10 random_list = random.sample(range(len(taging_image)), k=n) correct_image_list = list( models.QuerySet(Image_list).filter(sub=sub_selection, correct=1).values_list('image_path', flat=True)) correct_image = correct_image_list[random.randrange( len(correct_image_list))] res_image_list = [] res_id_list = [] for i, idx in enumerate(random_list): res_image_list.append(taging_image[idx]) res_id_list.append(taging_id[idx]) d = { 'res_image_list': res_image_list, 'res_id_list': res_id_list, 'correct_image': correct_image } return JsonResponse(d)
class Bill(models.Model): main_user = models.ForeignKey(MainUserProfile, on_delete=models.CASCADE, related_name="bills") discount = models.FloatField() added = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) objects = models.QuerySet() def __str__(self): return self.main_user.__str__()
class Menu(models.Model): main_user = models.ForeignKey(MainUserProfile, on_delete=models.CASCADE, related_name="menus") name = models.CharField(max_length=255) price = models.FloatField() added = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) objects = models.QuerySet() def __str__(self): return self.name
def test_recycle_bin_delete_is_permanent(self): ''' Assert that the recycle bin deletes objects for good on bulk deletion. ''' onbin = ShrewdQuerySet(self.model, on_recycle_bin=True) indb = models.QuerySet(self.model) pre_deletion_onbin_pks = [mo.pk for mo in onbin] self.assertEqual(indb.count(), 8) onbin.delete() self.assertEqual(indb.count(), 4) indb_pks = [mo.pk for mo in indb] for deleted_mo_pk in pre_deletion_onbin_pks: self.assertNotIn(deleted_mo_pk, indb_pks)
class SocialLink(models.Model): accounts = models.OneToOneField(Account, on_delete=models.CASCADE, related_name='social') facebook = models.URLField(null=True, blank=True) linkedin = models.URLField(null=True, blank=True) twitter = models.URLField(null=True, blank=True) quora = models.URLField(null=True, blank=True) github = models.URLField(null=True, blank=True) stack_overflow = models.URLField(null=True, blank=True) skype = models.URLField(null=True, blank=True) objects = models.QuerySet() def __str__(self): return self.accounts.__str__()
def bulk_update(self, objs: Iterable[Instance], fields: Iterable[str], batch_size: Optional[int] = base_settings.DB_BATCH_SIZE): if not objs: return self._for_write = True pks = [obj.pk for obj in objs] query_set = self.filter(pk__in=pks).order_by('pk') with transaction.atomic(): with db.connection.cursor() as cursor: cursor.execute(str(query_set.query) + ' FOR NO KEY UPDATE', ()) return models.QuerySet(self.model, using=self.db).bulk_update( objs, fields, batch_size)
class Permission(models.Model): """Individual Permissions""" user = models.OneToOneField(SubUserProfile, on_delete=models.CASCADE, related_name="sub_user_permission") # Inventory inventory_see = models.BooleanField(default=False) inventory_add = models.BooleanField(default=False) inventory_mod = models.BooleanField(default=False) # To be continued... objects = models.QuerySet() def __str__(self): return self.user
class JobDetail(models.Model): accounts = models.ForeignKey(Account, on_delete=models.CASCADE, related_name='jobs') job_from = models.DateField(help_text=date_format, blank=True, null=True) job_to = models.DateField(null=True, blank=True, help_text=date_format) currently = models.BooleanField(default=False, blank=True, null=True) designation = models.CharField(max_length=255, blank=True, null=True) institute_name = models.CharField(max_length=255, blank=True, null=True) institute_type = models.CharField(max_length=255, blank=True, null=True) institute_website = models.URLField(null=True, blank=True) institute_address = models.TextField(null=True, blank=True) objects = models.QuerySet() def __str__(self): return f'{self.institute_name} / {self.designation}'
class InventoryFoodOUT(models.Model): main_user = models.ForeignKey(MainUserProfile, on_delete=models.CASCADE, related_name='inventory_foods_out') name = models.ForeignKey(InventoryFoodIN, on_delete=models.CASCADE, related_name='inventory_foods_out') quantity = models.FloatField() date = models.DateField(default=now) added = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) objects = models.QuerySet() def __str__(self): return self.name.__str__()
class Account(models.Model): SESSIONS_CHOICE = ( ('2007-2008', '2007-2008'), ('2008-2009', '2008-2009'), ('2009-2010', '2009-2010'), ('2010-2011', '2010-2011'), ('2011-2012', '2011-2012'), ('2012-2013', '2012-2013'), ('2013-2014', '2013-2014'), ('2014-2015', '2014-2015'), ('2015-2016', '2015-2016'), ('2016-2017', '2016-2017'), ('2017-2018', '2017-2018'), ('2018-2019', '2018-2019'), ('2019-2020', '2019-2020'), ('2020-2021', '2020-2021'), ) DEPARTMENT_CHOICE = ( ('CSE', 'Computer Science and Engineering'), ) user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='account') first_name = models.CharField(max_length=255, null=True, blank=True, default=" ") last_name = models.CharField(max_length=255, null=True, blank=True, default=" ") birth_date = models.DateField(null=True, help_text=date_format, blank=True) department = models.CharField(max_length=255, choices=DEPARTMENT_CHOICE, null=True, blank=True) intake = models.PositiveSmallIntegerField(null=True, blank=True) graduation_year = models.PositiveSmallIntegerField(null=True, blank=True) session = models.CharField(choices=SESSIONS_CHOICE, max_length=50, null=True, blank=True) profile_picture = models.ImageField(null=True, blank=True) phone_number = PhoneNumberField(max_length=255, null=True, blank=True) present_address = models.TextField(null=True, blank=True) permanent_address = models.TextField(null=True, blank=True) email = models.EmailField(null=True, blank=True) objects = models.QuerySet() def __str__(self): return f'{self.first_name} {self.last_name}'
class MainUserProfile(models.Model): PACKAGE_CHOICES = ((1, "Basic"), (2, "Standard"), (3, "Premium")) user = models.OneToOneField(User, on_delete=models.CASCADE, related_name="main_user_profile") address = models.TextField() phone_number = models.CharField(max_length=55) birthday = models.DateField() _package = models.CharField(choices=PACKAGE_CHOICES, max_length=55) _added = models.DateTimeField(auto_now_add=True) _updated = models.DateTimeField(auto_now=True) _blocked = models.BooleanField(default=False) objects = models.QuerySet() def __str__(self): return self.user
class InventoryOtherIN(models.Model): user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='inventory_others_in') name = models.ForeignKey(InventoryOtherName, on_delete=models.CASCADE, related_name='inventory_others_in') quantity = models.FloatField() price = models.FloatField() date = models.DateField(default=now) added = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) objects = models.QuerySet() def __str__(self): return self.name
class SubUserProfile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE, related_name="sub_user_profile") main_user = models.ForeignKey(MainUserProfile, on_delete=models.CASCADE, related_name="sub_user_profile") address = models.TextField() phone_number = models.CharField(max_length=55) birthday = models.DateField() _added = models.DateTimeField(auto_now_add=True) _updated = models.DateTimeField(auto_now=True) _blocked = models.BooleanField(default=False) objects = models.QuerySet() def __str__(self): return self.user
def get_queryset(self, ids=None): table_name = convert(self.model.__name__) annotations = self._get_custom_annotation(table_name) if annotations is None: return models.QuerySet(self.model).none() column_names = self._get_columns_name() values = self._get_query_values(column_names) if ids is not None: object_set = Cell.objects.filter(primary_key__table__name=table_name, primary_key__id__in=ids).values('primary_key').annotate(**annotations).values(**values).order_by() else: object_set = Cell.objects.filter(primary_key__table__name=table_name).values('primary_key').annotate(**annotations).values(**values).order_by() object_set._fields = None object_set.update = types.MethodType(self.update, object_set) # bound delete() method object_set.delete = types.MethodType(self.delete, object_set) # bound delete() method return object_set
class InventoryFoodOUT(models.Model): user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='inventory_foods_out') name = models.ForeignKey(InventoryFoodIN, on_delete=models.CASCADE, related_name='inventory_foods_out') quantity = models.FloatField() date = models.DateField(default=now) added = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) objects = models.QuerySet() def __str__(self): return self.name def in_stock(self): if self.name.quantity >= self.quantity: return self.name.quantity - self.quantity return 0