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)
