def students(self, QObject=False): if QObject: return { 'student_profile': self.getQForUser( Q(registrationprofile__program=self.program, registrationprofile__student_info__isnull=False)) } students = ESPUser.objects.filter( registrationprofile__program=self.program, registrationprofile__student_info__isnull=False).distinct() return {'student_profile': students}
def prepare_context(self, program, target_path=None): context = {} context['program'] = program context['user_types'] = ESPUser.getTypes() category_lists = {} list_descriptions = program.getListDescriptions() # Add in program-specific lists for most common user types for user_type, list_func in zip(Program.USER_TYPES_WITH_LIST_FUNCS, Program.USER_TYPE_LIST_FUNCS): raw_lists = getattr(program, list_func)(True) category_lists[user_type] = [{ 'name': key, 'list': raw_lists[key], 'description': list_descriptions[key] } for key in raw_lists] for item in category_lists[user_type]: if item['name'] in UserSearchController.preferred_lists: item['preferred'] = True # Add in global lists for each user type for user_type in ESPUser.getTypes(): key = user_type.lower() + 's' if user_type not in category_lists: category_lists[user_type] = [] category_lists[user_type].insert( 0, { 'name': 'all_%s' % user_type, 'list': ESPUser.getAllOfType(user_type), 'description': 'All %s in the database' % key, 'preferred': True, 'all_flag': True }) # Add in mailing list accounts category_lists['emaillist'] = [{ 'name': 'all_emaillist', 'list': Q(password='******'), 'description': 'Everyone signed up for the mailing list', 'preferred': True }] context['lists'] = category_lists context['all_list_names'] = [] for category in category_lists: for item in category_lists[category]: context['all_list_names'].append(item['name']) if target_path is None: target_path = '/manage/%s/commpanel' % program.getUrlBase() context['action_path'] = target_path return context
def teachers(self, QObject=False): """Returns lists of teachers who've completed the teacher quiz.""" qo = Q(record__event=self.event, record__program=self.program) if QObject is True: return { 'quiz_done': qo, } else: return { 'quiz_done': ESPUser.objects.filter(qo).distinct(), }
def validate(self, attributes): """ Validate that the question has ties to the session. :param attributes: The values to validate :type attributes: dict :return: The validated values to create a reflection :rtype: dict """ session = attributes["session"] question = attributes["question"] clause = Q(set__session=session.id) & Q(id=question.id) if Question.objects.filter(clause).exist(): return attributes raise ValidationError( "The question doesn't have any ties to the session" )
def all_products(self): """ Return a queryset containing all the products in the range This includes included_products plus the products contained in the included classes and categories, minus the products in excluded_products. """ if self.proxy: return self.proxy.all_products() Product = get_model("catalogue", "Product") if self.includes_all_products: # Filter out child products return Product.browsable.all() return Product.objects.filter( Q(id__in=self._included_product_ids()) | Q(product_class_id__in=self._class_ids()) | Q(productcategory__category_id__in=self._category_ids()) ).exclude(id__in=self._excluded_product_ids())
def teachers(self, QObject=False): fts = ClassFlagType.get_flag_types(self.program) t = {} for flag_type in fts: q = Q(classsubject__flags__flag_type=flag_type.id, classsubject__parent_program=self.program) if QObject: t['flag_%s' % flag_type.id] = q else: t['flag_%s' % flag_type.id] = ESPUser.objects.filter(q).distinct() return t
def verify(self, token, view): """ Verify how many verifications are needed. :param token: The token to check :type token: rest_framework.authtoken.Token | knox.model.AuthToken :param view: The current view :type view: rest_framework.views.APIView | None :return: The number of verifications left :rtype: int """ filter = Q(token=token) & Q(confirm=True) queryset = unify_queryset(Challenge, fields=("id", ), filter=filter) # ticket: https://code.djangoproject.com/ticket/28399 if VERSION < (1, 11, 4): return self.get_verifications() - len(queryset) # pragma: no cover return self.get_verifications() - queryset.count() # pragma: no cover
def useNonce(self, server_url, timestamp, salt): if abs(timestamp - time.time()) > openid_store.nonce.SKEW: return False query = [ Q(server_url__exact=server_url), Q(timestamp__exact=timestamp), Q(salt__exact=salt), ] try: ononce = Nonce.objects.get(reduce(operator.and_, query)) except Nonce.DoesNotExist: ononce = Nonce(server_url=server_url, timestamp=timestamp, salt=salt) ononce.save() return True ononce.delete() return False
def tab_reception(request): orderitems = OrderItem.objects.filter(order__status=4) # Exclude items from local provider orderitems = orderitems.exclude(order__provider__is_local=True) # Exclude items with direct reception orderitems = orderitems.exclude(order__provider__direct_reception=True) # Exclude orphan products orderitems = orderitems.exclude(product_id__isnull=True, order__provider__is_service=False) # Only keep items ordered by request user or by its team if not request.user.has_perm("team.custom_view_teams"): orderitems = orderitems.filter( Q(username=request.user.username) | Q(order__team__in=get_teams(request.user))) return render(request, 'order/reception.html', {'orderitems': orderitems.order_by('order__number', 'name')})
def get_descendants(self, include_self=False): """ Creates a ``QuerySet`` containing descendants of this model instance, in tree order. If ``include_self`` is ``True``, the ``QuerySet`` will also include this model instance. """ if include_self: return self._tree_manager.filter( Q( left__gte=self.left, left__lte=self.right, tree_id=self.tree_id, ) | Q(pk=self.pk, )) else: return self._tree_manager.filter( left__gt=self.left, left__lt=self.right, tree_id=self.tree_id, ).exclude(pk=self.pk)
def get_users_geo(user: User) -> Dict: user_positions = UserPosition.objects.filter( ~Q(latitude=None, longitude=None)).exclude(user=user).all() user_positions_ser = UserPositionSerializer(user_positions, many=True) positions_with_score = [] for item in list(user_positions_ser.data): user_data = dict(item) user_data['score'] = AnswerMark.objects.filter( answer__commentator=user_data.get('id')).all().aggregate( Avg('mark'))['mark__avg'] positions_with_score.append(user_data) return {"success": True, "data": positions_with_score}
def user_message(request): my_send = models.Message.objects.filter(senderID=request.user) my_recv = models.Message.objects.filter(receiverID=request.user) talker = my_send.values('receiverID').union(my_recv.values('senderID')) msg = {} for ele in talker: obj = models.User.objects.get(id=ele['receiverID']) to_obj = models.Message.objects.filter( Q(senderID=request.user, receiverID=obj) | Q(receiverID=request.user, senderID=obj)).order_by('time_stamp') # print(obj) # print(to_obj) msg[obj] = to_obj # print(msg) first = None if len(talker) > 0: first = talker[0]['receiverID'] return render(request, 'user/user_message.html', { 'messages': msg, 'first': first })
def get(self, request, business_id, business_location_id): grower_filter = request.GET.get('grower_id') dispensary_filter = request.GET.get('dispensary_id') partnerships = GrowerDispensaryPartnership.objects.select_related('dispensary', 'grower', 'dispensary__state_fk', 'grower__state_fk', 'dispensary__city_fk', 'grower__city_fk', ) if not grower_filter or not dispensary_filter: f = Q(grower_id=business_location_id) | Q(dispensary_id=business_location_id) elif grower_filter and dispensary_filter: f = Q(grower_id=grower_filter) & Q(dispensary_id=dispensary_filter) elif grower_filter: f = Q(grower_id=grower_filter) else: f = Q(dispensary_id=dispensary_filter) partnerships = partnerships.filter(f).order_by('dispensary__location_name') return Response( {'partnerships': [GrowerDispensaryPartnershipSerializer(x).data for x in partnerships]}, status=status.HTTP_200_OK )
def clean(self): access_token = self.cleaned_data.get('access_token') secret = self.cleaned_data.get('secret') headers = {'Content-Type': 'application/json', 'Authorization': 'Bearer %s' % access_token} headers.update(TEMBA_HEADERS) response = requests.get('https://api.line.me/v1/oauth/verify', headers=headers) content = response.json() if response.status_code != 200: raise ValidationError(content.get('error_desciption')) else: channel_id = content.get('channelId') channel_mid = content.get('mid') credentials = { 'channel_id': channel_id, 'channel_mid': channel_mid, 'channel_access_token': access_token, 'channel_secret': secret } existing = Channel.objects.filter( Q(config__contains=channel_id) | Q(config__contains=secret) | Q( config__contains=access_token), channel_type=self.channel_type.code, address=channel_mid, is_active=True).first() if existing: raise ValidationError(_("A channel with this configuration already exists.")) headers.pop('Content-Type') response_profile = requests.get('https://api.line.me/v1/profile', headers=headers) content_profile = json.loads(response_profile.content) credentials['profile'] = { 'picture_url': content_profile.get('pictureUrl'), 'display_name': content_profile.get('displayName') } return credentials
def product_queryset(self): "cached queryset of all the products in the Range" Product = self.included_products.model if self.includes_all_products: # Filter out child products and blacklisted products return Product.objects.browsable().exclude( id__in=self.excluded_products.values("id") ) Category = self.included_categories.model # build query to select all category subtrees. included_in_subtree = self.included_categories.filter( path__rstartswith=OuterRef("path"), depth__lte=OuterRef("depth") ) category_tree = Category.objects.annotate( is_included_in_subtree=Exists(included_in_subtree.values("id")) ).filter(is_included_in_subtree=True) # select all those product that are selected either by product class, # category, or explicitly by included_products. selected_parents = ( Product.objects.filter( Q(product_class_id__in=self.classes.values("id")) | Q(categories__in=category_tree) ) | self.included_products.all() ) # select parents and their children selected_products = ( selected_parents | Product.objects.filter(parent__in=selected_parents) ) # now go and exclude all explicitly excluded products excludes = self.excluded_products.values("id") return selected_products.exclude( Q(parent_id__in=excludes) | Q(id__in=excludes) ).distinct()
def insertion_target_filters(self, instance, order_insertion_by): """ Creates a filter which matches suitable right siblings for ``node``, where insertion should maintain ordering according to the list of fields in ``order_insertion_by``. For example, given an ``order_insertion_by`` of ``['field1', 'field2', 'field3']``, the resulting filter should correspond to the following SQL:: field1 > %s OR (field1 = %s AND field2 > %s) OR (field1 = %s AND field2 = %s AND field3 > %s) """ fields = [] filters = [] fields__append = fields.append filters__append = filters.append and_ = operator.and_ or_ = operator.or_ for field_name in order_insertion_by: if field_name[0] == '-': field_name = field_name[1:] filter_suffix = '__lt' else: filter_suffix = '__gt' value = getattr(instance, field_name) if value is None: # node isn't saved yet. get the insertion value from pre_save. field = instance._meta.get_field(field_name) value = field.pre_save(instance, True) q = Q(**{field_name + filter_suffix: value}) filters__append( reduce(and_, [Q(**{f: v}) for f, v in fields] + [q])) fields__append((field_name, value)) return reduce(or_, filters)
def students(self, QObject=False): Q_accepted = Q( studentregistration__relationship__name='Accepted', studentregistration__section__parent_class__parent_program=self. program) if QObject: return {'app_accepted_to_one_program': Q_accepted} else: return { 'app_accepted_to_one_program': ESPUser.objects.filter(Q_accepted).distinct() }
def teachers(self, QObject=False): """ Returns a list of teachers who have indicated at least one segment of teaching availability for this program. """ qf = Q(useravailability__event__program=self.program, useravailability__role__name='Teacher') if QObject is True: return {'availability': qf} teacher_list = ESPUser.objects.filter(qf).distinct() return { 'availability': teacher_list } #[t['user'] for t in teacher_list]}
def teachers(self, QObject=False): """ Returns a list of teachers who have indicated at least one segment of teaching availability for this program. """ qf = Q(useravailability__event__anchor=self.program_anchor_cached(), useravailability__role=self.teacher_role_node) if QObject is True: return {'availability': self.getQForUser(qf)} teacher_list = ESPUser.objects.filter(qf).distinct() return { 'availability': teacher_list } #[t['user'] for t in teacher_list]}
def issue_list(request): condition = request.GET.get('table_search', '') # Issue.objects.filter(project__test__test_user=) if request.path_info == reverse('update_list'): page_type = '更新记录' all_obj = Issue.objects.filter( Q(release_user=request.account) | Q(project__test=request.account), project__name__contains=condition) # Q查询必须放在前面 else: page_type = '回滚记录' all_obj = Issue.objects.filter(Q(release_user=request.account) | Q(project__test=request.account), project__name__contains=condition, status="6") pager = Pagination(request.GET.get('page', '1'), all_obj.count(), request.GET.copy(), 10) return TemplateResponse( request, 'issue.html', { "page_type": page_type, 'page_html': pager.page_html, 'all_obj': all_obj[pager.start:pager.end] })
def filtercrime(request): if request.method == "GET": sex, gouv, cat = None, None, None if "sex" in request.GET: sex = request.GET["sexe"] if "gouvernorat" in request.GET: gouv = request.GET["gouvernorat"] if "crimetype" in request.GET: cat = request.GET["crimetype"] q = Q() if sex: q = q & Q(sexe=sex) if gouv: q = q & Q(gouvernorat=gouv) if cat: q = q & Q(crimetype=cat) crimes = crime.objects.filter(q) crimes = list(crimes.values_list("gouvernorat", "position", "crimetype", "time")) return HttpResponse(json.dumps(crimes, cls=DjangoJSONEncoder), content_type="application/json") else: return HttpResponse()
def filter_queryset(self, queryset): """ Filter the queryset for the appropriate users. :param queryset: The queryset to filter :type queryset: django.db.models.query.QuerySet :return: The queryset with the appropriate allowed users :rtype: django.db.models.query.QuerySet """ query = Q() if is_employee(self.request.user, False): query &= Q(id=self.request.user.id) if is_employer(self.request.user, False): query &= Q(group=Groups.employee) query &= Q(member__company=self.request.user.member.company) if is_management(self.request.user, False): query &= ~Q(group=Groups.admin) return queryset.filter(query)
def test_function_field01(self): funf = function_field_registry.get(CremeEntity, 'assistants-get_todos') self.assertIsInstance(funf, TodosField) self.assertEqual('<ul></ul>', funf(self.entity, self.user).for_html()) # --- field_class = funf.search_field_builder self.assertIsNotNone(field_class) field = field_class( cell=EntityCellFunctionField(model=FakeContact, func_field=funf), user=self.user, ) self.assertIsInstance(field.widget, TextLVSWidget) to_python = field.to_python self.assertEqual(Q(), to_python(value=None)) self.assertEqual(Q(), to_python(value='')) value = 'foobar' self.assertEqual(Q(assistants_todos__title__icontains=value), to_python(value=value))
def students(self, QObject=False): # this should be fixed...this is the best I can do for now - Axiak # I think this is substantially better; it's the same thing, but in one query. - Adam #transactions = Transaction.objects.filter(anchor = self.program_anchor_cached()) #userids = [ x.document_id for x in documents ] QObj = Q(document__anchor=self.program_anchor_cached(), document__doctype=3, document__cc_ref__gt='') if QObject: return {'creditcard': QObj} else: return {'creditcard': ESPUser.objects.filter(QObj).distinct()}
def get_ordered_insertion_target(self, node, parent): """ Attempts to retrieve a suitable right sibling for ``node`` underneath ``parent`` (which may be ``None`` in the case of root nodes) so that ordering by the fields specified by the node's class' ``order_insertion_by`` option is maintained. Returns ``None`` if no suitable sibling can be found. """ right_sibling = None # Optimisation - if the parent doesn't have descendants, # the node will always be its last child. if parent is None or parent.get_descendant_count() > 0: opts = node._mptt_meta order_by = opts.order_insertion_by[:] filters = self.insertion_target_filters(node, order_by) if parent: filters = filters & Q(**{opts.parent_attr: parent}) # Fall back on tree ordering if multiple child nodes have # the same values. order_by.append(opts.left_attr) else: filters = filters & Q(**{opts.parent_attr: None}) # Fall back on tree id ordering if multiple root nodes have # the same values. order_by.append(opts.tree_id_attr) queryset = ( node.__class__._tree_manager.db_manager(node._state.db) .filter(filters) .order_by(*order_by) ) if node.pk: queryset = queryset.exclude(pk=node.pk) try: right_sibling = queryset[:1][0] except IndexError: # No suitable right sibling could be found pass return right_sibling
def handle(self, *args, **kwargs): """Handle a call to the command.""" if kwargs["command"] == "list": for competition in models.Competition.objects.all(): print(" {1:<2} {0.id:<12} {0.name:<20}".format(competition, "*" if competition.active else "")) if kwargs["command"] == "delete": models.Competition.current().delete() if kwargs["command"] == "load": start = time.time() path = kwargs["file"] if not os.path.isfile(path): raise CommandError("Path is invalid!") load(path) print("Done in {} seconds!".format(round(time.time() - start, 3))) if kwargs["command"] == "activate": search = kwargs["id"] selected = models.Competition.objects.filter(Q(id=search) | Q(name=search)).first() selected.activate()
def get_queryset(self, request): queryset = super().get_queryset(request) if request.user.is_superuser: queryset = queryset.filter() elif request.user.role == 'headman': member = MemberGroup.objects.filter(member_user=request.user).first() if member: queryset = queryset.filter(academic_group=member.member_group) elif request.user.role in ['teacher', 'curator', 'head_department']: tutor_lectures = TutorName.objects.filter(teacher=request.user).all() lectures = [lec.lecture for lec in tutor_lectures] queryset = queryset.filter(Q(lecture__in=lectures) | Q(academic_group__curator=request.user)) else: return queryset.none() # queryset = [] # elif request.user.role == 'head_department': # queryset = queryset.filter(lecture__teacher=request.user) # # head_department # lecture return queryset
def event_signup(self, request, tl, one, two, module, extra, prog): if request.method == 'POST': form = TeacherEventSignupForm(self, request.POST) if form.is_valid(): data = form.cleaned_data # Remove old bits [ ub.expire() for ub in UserBit.objects.filter( Q(qsc__parent=self.qscs['interview']) | Q(qsc__parent=self.qscs['training']), UserBit.not_expired(), user=request.user, verb=self.reg_verb ) ] # Register for interview if data['interview']: ub, created = UserBit.objects.get_or_create( user=request.user, qsc=data['interview'], verb=self.reg_verb, defaults={'recursive':False} ) # Send the directors an e-mail if self.program.director_email and (created or ub.enddate < datetime.now() ): event_names = ' '.join([x.description for x in data['interview'].event_set.all()]) send_mail('['+self.program.niceName()+'] Teacher Interview for ' + request.user.first_name + ' ' + request.user.last_name + ': ' + event_names, \ """Teacher Interview Registration Notification\n--------------------------------- \n\nTeacher: %s %s\n\nTime: %s\n\n""" % \ (request.user.first_name, request.user.last_name, event_names) , \ ('%s <%s>' % (request.user.first_name + ' ' + request.user.last_name, request.user.email,)), \ [self.program.director_email], True) if not created: ub.enddate = datetime(9999,1,1) # Approximately infinity; see default value of UserBit.enddate ub.save() # Register for training if data['training']: ub, created = UserBit.objects.get_or_create( user=request.user, qsc=data['training'], verb=self.reg_verb, defaults={'recursive':False} ) if not created: ub.enddate = datetime(9999,1,1) # Approximately infinity ub.save() return self.goToCore(tl) else: data = {} bits = self.bitsByTeacher(request.user) if bits['interview'].count() > 0: data['interview'] = bits['interview'][0].qsc.id if bits['training'].count() > 0: data['training'] = bits['training'][0].qsc.id form = TeacherEventSignupForm(self, initial=data) return render_to_response( self.baseDir()+'event_signup.html', request, (prog, tl), {'prog':prog, 'form': form} )
def useNonce(self, server_url, timestamp, salt): if not openid.store.nonce.checkTimestamp( openid.store.nonce.mkNonce(timestamp)): return False query = [ Q(server_url__exact=server_url), Q(timestamp__exact=timestamp), Q(salt__exact=salt), ] try: ononce = Nonce.objects.get(reduce(operator.and_, query)) except Nonce.DoesNotExist: ononce = Nonce(server_url=server_url, timestamp=timestamp, salt=salt) ononce.save() return True ononce.delete() return False
def get_ancestors(self, ascending=False, include_self=False): """ Creates a ``QuerySet`` containing the ancestors of this model instance. This defaults to being in descending order (root ancestor first, immediate parent last); passing ``True`` for the ``ascending`` argument will reverse the ordering (immediate parent first, root ancestor last). If ``include_self`` is ``True``, the ``QuerySet`` will also include this model instance. """ if self.is_root_node(): if include_self: # Filter on pk for efficiency. return self._tree_manager.filter(pk=self.pk) else: return self._tree_manager.none() else: if ascending: order_by = '-left' else: order_by = 'left' if include_self: return self._tree_manager.filter( Q( left__lte=self.left, right__gte=self.right, tree_id=self.tree_id, ) | Q(pk=self.pk, )).order_by(order_by) else: return self._tree_manager.filter( left__lt=self.left, right__gt=self.right, tree_id=self.tree_id, ).exclude(pk=self.pk).order_by(order_by)