def send_email():
dishes = Dish.objects.filter(modified__gte=(date.today() -
datetime.timedelta(days=1)))
menus = Menu.objects.filter(modified__gte=(date.today() -
datetime.timedelta(days=1)))
users = User.objects.all()
for user in users:
html_message = render_to_string(
'email_template.html',
{
'host_url': 'http://127.0.0.1:8000/',
'dishes': dishes,
'menus': menus,
'username': user.username
},
)
email = EmailMultiAlternatives(
subject='eMenu - najnowsze informacje',
from_email='*****@*****.**',
to=(user.email, ),
)
email.attach_alternative(html_message, "text/html")
email.send()
def test_filter_students_by_current_internship(self):
period = PeriodFactory(cohort=self.cohort,
date_start=date.today(),
date_end=date.today())
student_info = InternshipStudentInformationFactory(
cohort=self.cohort, person=self.student_1.person)
affectation = StudentAffectationStatFactory(student=self.student_1,
period=period)
url = reverse(internships_student_resume,
kwargs={
'cohort_id': self.cohort.id,
})
response = self.client.get(url)
actual, stats = student._get_students_with_status(
request=response.wsgi_request,
cohort=self.cohort,
filters=(None, True))
expected = [student_info]
self.assertCountEqual(expected, actual)
for item_expected in expected:
self.assertIn(item_expected, actual)
self.assertEqual(
actual[0].current_internship,
"{}{}".format(affectation.speciality.acronym,
affectation.organization.reference))
def home(request):
club_data = Club.objects.all()
club_count = Club.objects.all().count()
event_count = Event.objects.all().count()
clubmember_count = ClubMember.objects.all().count()
club_data = Club.objects.all()
first = date.today()
second = date.today() + datetime.timedelta(days=1)
third = date.today() + datetime.timedelta(days=2)
fourth = date.today() + datetime.timedelta(days=3)
first_event_data = Event.objects.filter(start=first)
second_event_data = Event.objects.filter(start=second)
third_event_data = Event.objects.filter(start=third)
forth_event_data = Event.objects.filter(start=fourth)
context = {
'fourth': fourth,
'third': third,
'second': second,
'first': first,
'first_event_data': first_event_data,
'forth_event_data': forth_event_data,
'third_event_data': third_event_data,
'second_event_data': second_event_data,
'club_data': club_data,
'club_count': club_count,
'event_count': event_count,
'clubmember_count': clubmember_count
}
return render(request, 'client/home.html', context)
def add_crm_mail(email_, mail_content, mail_subject, user):
typeofservice = Typeofservice.objects.get(id=1)
user = User.objects.get(id=user.id)
try:
id_department, subject = mail_subject.split('-')
except ValueError:
id_department = 1
print(id_department)
try:
client = Client.objects.get(email=email_)
Atendimento.objects.get_or_create(type=typeofservice,
department=id_department,
person=client,
contact=email_,
feedback=mail_content,
deadline=date.today(),
user_id=user.id)
except Client.DoesNotExist:
client_default = Client.objects.get(id=1)
Atendimento.objects.get_or_create(
type=typeofservice,
department='1',
person=client_default,
contact=email_,
feedback='Este e-mail não pertence a nenhum cliente' + '\n' +
mail_content,
deadline=date.today(),
user_id=user.id)
def setUp(self) -> None:
User.objects.create_user('test')
poll = Poll.objects.create(name='Проверочный опрос',
start_date=date.today(),
end_date=date.today(),
description='Описание для опроса')
yesterday = date.today() - timedelta(days=1)
Poll.objects.create(name='Неактивный опрос', start_date=yesterday,
end_date=yesterday,
description='Описание для опроса')
self.text_answer_question = Question.objects.create(
text='Как работают Middleware?',
type=Question.TypeChoices.TEXT_ANSWER, poll=poll)
self.single_answer_question = Question.objects.create(
text='Django или Flask?', type=Question.TypeChoices.SINGLE_ANSWER,
poll=poll)
AnswerOption.objects.create(question=self.single_answer_question,
content='Django')
AnswerOption.objects.create(question=self.single_answer_question,
content='Flask')
self.several_options_answer_question = Question.objects.create(
text='Какие возможности в Django?',
type=Question.TypeChoices.SEVERAL_OPTIONS_ANSWER,
poll=poll)
AnswerOption.objects.create(
question=self.several_options_answer_question, content='ASGI')
AnswerOption.objects.create(
question=self.several_options_answer_question, content='WSGI')
AnswerOption.objects.create(
question=self.several_options_answer_question, content='ML')
def setUp(self) -> None:
poll = Poll.objects.create(
name='Проверочный опрос', start_date=date.today(),
end_date=date.today(), description='Описание для опроса')
Question.objects.create(text='Что должно здесь быть?',
type=Question.TypeChoices.TEXT_ANSWER,
poll=poll)
def job(request,job_slug=None,start_date=None,end_date=None,latest_count=10):
#print request.META
if job_slug:
summary = None
job = Job.objects.get(slug=job_slug)
job_metrics = job.metrics.all()
try:
job.extra_display_fields = [df.strip() for df in job.config.display_extra_fields.split(',')]
if len(job.config.multipart_field):
if start_date is None and end_date is None:
start_date = date.today()
end_date = date.fromordinal(date.today().toordinal() + 1)
except Exception, ex:
print str(ex)
job.extra_display_fields = ['log',]
#this is where we decide how many and which notifications to display!!!!
if start_date is not None and end_date is not None:
notifications = job.notifications.filter(at__gte=start_date,at__lt=end_date)
else:
notifications = job.notifications.all()[:latest_count]
notifications = [n for n in notifications]
multipart = False
multipart_field = None
multipart_values = {}
try:
if len(job.config.multipart_field):
multipart = True
multipart_field = job.config.multipart_field
for v in job.config.multipart_names.split(','):
multipart_values[v.strip()] = None
except Exception, ex:
pass
def handle(self, *args, **options):
start_date = options['start_date']
end_date = options['end_date']
if not (start_date and end_date) and (start_date or end_date):
raise CommandError(
"You must specify both --date-from and --date-to "
"to import research summaries for a given period."
)
if start_date:
try:
start_date = parse_date(start_date).date()
except ValueError:
raise CommandError("Invalid --date-from: '{}'".format(start_date))
if end_date:
if end_date == 'today':
end_date = date.today()
else:
try:
end_date = parse_date(end_date).date()
except ValueError:
raise CommandError("Invalid --date-to: '{}'".format(end_date))
if not (start_date and end_date):
# If there is no dates in arguments,
# use the date of the last import as a start date,
# and the current date as an end date
end_date = date.today()
last_updated_at = ResearchSummaryPage.objects.aggregate(last_updated_at=models.Max('updated_at'))
last_updated_at = last_updated_at.get('last_updated_at')
if not last_updated_at:
raise CommandError(
"No research summaries were imported before. "
"You have to run import and specify date range manually."
)
start_date = last_updated_at.date()
parent_page = ResearchSummariesIndexPage.objects.first()
logger.info('Importing research summaries %s - %s', start_date, end_date)
if not parent_page:
raise CommandError(
"There is no ResearchSummariesIndexPage pages. "
"You have to create one to be able to import research summaries."
)
fetch_chunks_for_dates(parent_page, start_date, end_date)
def _get_students_with_status(request, cohort, filters):
active_period = Period.objects.filter(cohort=cohort,
date_start__lte=date.today(),
date_end__gte=date.today()).first()
internship_ids = Internship.objects.filter(cohort=cohort).values_list(
'pk', flat=True)
current_internship_subquery = InternshipStudentAffectationStat.objects.filter(
student__person=OuterRef('person'), period=active_period)
student_internships_count = InternshipChoice.objects.filter(
internship__pk__in=internship_ids,
choice=1,
student__person=OuterRef('person')).values('student').annotate(
count=Count('internship')).values('count')
students_info = InternshipStudentInformation.objects\
.filter(cohort=cohort)\
.prefetch_related(Prefetch('person__student_set', to_attr='students'))\
.order_by('person__last_name', 'person__first_name')\
.annotate(
current_internship=Concat(
Subquery(current_internship_subquery.values('speciality__acronym')),
Subquery(current_internship_subquery.values('organization__reference'))
),
chosen_internships_count=Subquery(student_internships_count, output_field=models.IntegerField()),
total_count=Value(internship_ids.count(), output_field=models.IntegerField())
).annotate(
status=F('chosen_internships_count')-F('total_count')
)
status_stats = {
'OK': students_info.filter(status__gte=0).count(),
'NOK': students_info.filter(status__lt=0).count(),
'UNKNOWN': students_info.filter(status__isnull=True).count(),
}
if filters:
filter_name, filter_current_internship = filters
if filter_name:
students_info = students_info.filter(person__last_name__unaccent__icontains=filter_name) | \
students_info.filter(person__first_name__unaccent__icontains=filter_name)
if filter_current_internship:
students_info = students_info.exclude(
Q(current_internship__isnull=True)
| Q(current_internship__exact=''))
paginated_students_info = get_object_list(request, students_info)
return paginated_students_info, status_stats
def detail(request, course_id):
try:
course = Course.objects.get(id=course_id)
exams = course.exam_set.filter(end_date__gte = date.today())
except Course.DoesNotExist:
raise Http404
return render_to_response('course_detail.html', {'exams': exams, 'course' : course}, RequestContext(request))
class Reservation(models.Model):
STATUS = (
('New', 'New'),
('Accepted', 'Accepted'),
('Completed', 'Completed'),
('Canceled', 'Canceled'),
)
car = models.ForeignKey(Car, on_delete=models.CASCADE)
user = models.ForeignKey(User, on_delete=models.CASCADE)
name = models.CharField(max_length=50, blank=True)
surname = models.CharField(max_length=50, blank=True)
phone = models.CharField(blank=True, max_length=20)
start_from = models.CharField(max_length=50, blank=True)
destination_to = models.CharField(max_length=50, blank=True)
distance = models.IntegerField(blank=True)
time = models.CharField(blank=True, max_length=10)
kisi_sayisi = models.IntegerField(blank=True, null=True)
status = models.CharField(max_length=10, choices=STATUS, default='New')
date = models.DateField(default=date.today().strftime('%Y-%m-%d'),
blank=True)
address = models.TextField(max_length=100, blank=True)
adminnote = models.CharField(blank=True, max_length=100)
create_at = models.DateTimeField(auto_now_add=True)
update_at = models.DateTimeField(auto_now=True)
def __str__(self):
return self.name
@property
def total(self):
return (self.distance * self.car.price)
@property
def price(self):
return (self.car.price)
def test_view_loads_correct_data(self):
today = date.today()
user1 = User.objects.create(
username='******', email='*****@*****.**', password='******',
first_name='User', last_name='1', is_active=True
)
user2 = User.objects.create(
username='******', email='*****@*****.**', password='******',
first_name='User', last_name='2', is_active=True
)
UserInfo.objects.create(user=user1, year=today.year - 1)
UserInfo.objects.create(user=user2, year=today.year - 2)
value = str(user1.pk) + ' Y, ' + str(user2.pk) + ' N'
StatusUpdate.objects.create(
date=today, value=value)
response = self.client.get(
reverse('status-update-detail', kwargs={
'day': today.day, 'month': today.month, 'year': today.year}))
self.assertIn('User 1', response.content.decode('utf8'))
self.assertIn('User 2', response.content.decode('utf8'))
def get_queryset(self):
user = self.request.user
year = self.request.GET.get('year')
month = self.request.GET.get('month')
day = self.request.GET.get('day')
if not year or not month:
today = date.today()
year = today.year
month = today.month
if not day:
queryset = Calendar.objects.filter(show_time__month=month,
show_time__year=year)
else:
queryset = Calendar.objects.filter(show_time__day=day,
show_time__month=month,
show_time__year=year)
queryset_ret = queryset.filter(user=user)
if user.team:
queryset_ret |= queryset.filter(team=user.team)
if user.major:
queryset_ret |= queryset.filter(major=user.major)
if user.faculty:
queryset_ret |= queryset.filter(faculty=user.faculty)
if user.classes:
queryset_ret |= queryset.filter(classes=user.classes)
return queryset_ret
def update(self, instance, validated_data):
user = self.context.get('request').user
authorized_reas = get_user_reas(user).all()
rea = instance.bed.unit.reanimation_service
if rea is None:
raise serializers.ValidationError('The reanimation service could not be found.')
if rea not in authorized_reas:
raise PermissionDenied
new_bed_id = validated_data.pop("id_bed", None)
if new_bed_id:
if int(new_bed_id) != instance.bed.id:
new_bed = Bed.objects.filter(id=new_bed_id).first()
if new_bed is None:
raise serializers.ValidationError(f"Le lit demandé (${new_bed_id}) n'existe pas")
new_bed_rea = new_bed.unit.reanimation_service
if new_bed_rea not in authorized_reas:
raise serializers.ValidationError(f"Le lit demandé (${new_bed_id}) appartien au "
f"service ${new_bed_rea}. Vous n'avez pas les accès.")
if new_bed.current_stay:
raise serializers.ValidationError(f"Le lit demandé (${new_bed_id}) est déjà occupé.")
if new_bed.is_unusable:
raise serializers.ValidationError(f"Le lit demandé (${new_bed_id}) n'est pas en état de service.")
validated_data["bed"] = new_bed
terminate = validated_data.pop("terminate", None)
if terminate:
validated_data["end_date"] = date.today()
return super(UnitStaySerializer, self).update(instance, validated_data)
def get_fechas(self):
now = date.today()
self.fin = date(now.year, now.month,
calendar.monthrange(now.year, now.month)[1])
self.inicio = date(now.year, now.month, 1)
self.inicio = datetime.combine(self.inicio, time.min)
self.fin = datetime.combine(self.fin, time.max)
class TodayList(generics.ListAPIView):
today_date = date.today()
queryset = Meeting.objects.filter(date=today_date)
serializer_class = BasicMeetingSerializer
permission_classes = (IsAuthenticated, )
def test_chart(request):
try:
measures = []
measures_label = []
for idx in reversed(range(7)):
energy = 0
past_date = date.today() - timedelta(days=idx)
try:
daily_measures_queryset = Measure.objects.filter(
created_at__day=past_date.day,
created_at__month=past_date.month,
created_at__year=past_date.year)
for measure in daily_measures_queryset:
energy += measure.active_power
energy = (energy / daily_measures_queryset.count()) * 24 / 1000
except:
energy = 0
measures.append(energy)
measures_label.append(past_date)
return JsonResponse({
'valid': True,
'chart_values': measures,
'chart_labels': measures_label
})
except:
return JsonResponse({'valid': False, 'error_message': "Deu pau."})
def test_StrictDateField_form_with_instance_invalid():
today = date.today()
x = DateFieldModel(field=today)
form_class = modelform_factory(model=DateFieldModel, fields=['field'])
form = form_class(data={'field': 9223372036854775808}, instance=x)
assert form.is_valid() is False
assert form.errors == {'field': ['Enter a valid date.']}
def test_StrictDateField_form_without_instance_valid():
today = date.today()
form_class = modelform_factory(model=DateFieldModel, fields=['field'])
form = form_class(data={'field': today})
assert form.is_valid() is True
assert form.errors == {}
assert form.save().field == today
def today(self):
today = date.today()
return today.replace(day=1,
month=int(
self.kwargs.get('month', str(today.month))),
year=int(self.kwargs.get('year',
str(today.year))))
def post(self, request, slug):
answer_question = Question.objects.get(slug=slug)
body = request.POST['details']
writer = UserOtherDetails.objects.get(user=request.user)
date_written = date.today()
time_written = timezone.now().time().strftime('%H:%M')
question = answer_question
answer = Answer()
answer.question_string = answer_question.title
answer.body = body
answer.writer = writer
answer.date_written = date_written
answer.time_written = time_written
answer.question = question
answer.save()
answer_question.no_of_answers += 1
answer_question.save()
writer.increase_no_of_answers()
writer.save()
return redirect('/questions/' + question.slug)
def queryset(self, request, queryset):
val = self.value()
today = date.today()
# note: groups with no related item (groupismajority) will be considered
# as not in council
if val == '1':
queryset = queryset.exclude(groupismajority__isnull=True).filter(
Q(groupismajority__end_date__gt=today)
| Q(groupismajority__end_date__isnull=True))
elif val == '0':
# the check for groups NOT in majority is more complex because
# we have to check that ALL related objects (groupismajority)
# have an end_date previous the current date
groups_in_council = Group.objects.exclude(
groupismajority__isnull=True).filter(
Q(groupismajority__end_date__gt=today)
| Q(groupismajority__end_date__isnull=True))
queryset = queryset.exclude(pk__in=groups_in_council)
return queryset
def reminder_cronjob():
today = date.today()
semester = current_semester()
fahrt_date_reminder(semester, today)
fahrt_payment_reminder(semester, today)
tutor_reminder(semester, today)
guidedtour_reminder(semester, today)
def edit_equipment(request, asset_id=None):
instance = get_object_or_404(Equipment, asset_id=asset_id)
form = EquipmentForm(request.POST or None, instance=instance)
if form.is_valid():
equipment = form.save(commit=False)
equipment.category_id = equipment.model.model_category_id
equipment.risk_score = equipment.category.category_risk_score + equipment.department.department_risk_score
if equipment.risk_score > 6:
equipment.ppm_intervel = 180
else:
equipment.ppm_intervel = 365
equipment.next_service_date = equipment.service_date + datetime.timedelta(days=equipment.ppm_intervel)
d = (equipment.next_service_date - date.today()).days
equipment.ppm_due_days = d
equipment.save()
instance = equipment
i = Equipment.objects.get(pk=instance.asset_id)
i.risk_score = i.category.category_risk_score + i.department.department_risk_score
i.save()
return redirect('view_equipment', asset_id)
context = {
"title": 'Edit ' + str(instance.asset_id),
"instance": instance,
"form": form,
"asset_id": asset_id,
}
return render(request, "edit_equipment.html", context)
def update_signin_attempts(self, failed: bool):
"""
:param failed if `True` a failed sign-in attempt count is incremented by one(+1) which will in turn translate
to a minus one(-1) remaining attempts. If `False` failed attempts are reset to zero (0) and the remaining
attempts are set to -1.
:return: number of sign-in attempts left until account is deactivated
"""
_, metered = max_sign_in_attempts()
attempt, created = FailedSignInAttempt.objects.get_or_create(user=self)
count_attr = 'attempt_count'
zero_attempts_count = models.F(count_attr) - models.F(count_attr)
if created:
# new record was created
if failed:
attempt_count = attempt.attempt_count
else:
# sign-in was considered successful. Reset attempt count to 0
attempt_count = zero_attempts_count
else:
# existing record was found
if failed:
attempt_count = models.F(count_attr) + 1
else:
# sign-in was considered successful. Reset attempt count to 0
attempt_count = zero_attempts_count
attempt.device_ip = self.device_ip
attempt.attempt_date = dj_date.today()
# if attempts are metered, use the latest attempt count otherwise
# maintain it to zero i.e. assume there hasn't been a failed attempt
attempt.attempt_count = attempt_count if metered else 0
attempt.save()
attempt.refresh_from_db()
return self.__remaining_attempts(attempt) if failed else attempt.attempt_count - 1
def test_StrictDateField_ok_until_changed():
"""
Ensure this value cannot change to an invalid state after being set
"""
model = DateFieldModel(field=date.today())
with pytest.raises(ValidationError):
model.field = '2000-00-00'
def get_initial(self):
init = super().get_initial()
init.update({
'year': date.today().year
})
return init
def list(self, request, *args, **kwargs):
target_seeker = self.get_object()
queryset = target_seeker.made_requests.filter((
Q(valid_until__gt=date.today()) & Q(status="OP")) | Q(
Q(selected_donor=self.request.user.donor_profile)
& Q(status="CL"))).order_by('-created')
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
def test_polls_are_active(self):
url = reverse('active_polls')
response = self.client.get(url)
expected_response = [
{'id': 3, 'question_set': [
{'id': 4, 'text': 'Как работают Middleware?',
'type': 'TEXT_ANSWER'},
{'id': 5, 'text': 'Django или Flask?',
'type': 'SINGLE_ANSWER'},
{'id': 6, 'text': 'Какие возможности в Django?',
'type': 'SEVERAL_OPTIONS_ANSWER'}],
'name': 'Проверочный опрос', 'start_date': str(date.today()),
'end_date': str(date.today()),
'description': 'Описание для опроса'}]
self.assertListEqual(response.json(), expected_response)
self.assertEqual(response.status_code, HTTP_200_OK)
def test_create_user_account_for_internship_master(self,
mock_ldap_api_call):
master = MasterFactory(person=PersonFactory(birth_date=date.today()))
url = reverse('create_accounts', kwargs={'cohort_id': self.cohort.pk})
response = self.client.post(url, data={'selected_master': [master.pk]})
messages_list = [msg for msg in response.wsgi_request._messages]
self.assertEqual(messages_list[0].level_tag, "success")
self.assertIn(str(master.person), messages_list[0].message)
def test_StrictDateField_update_via_queryset_invalid_then_get():
"""
So for whatever reason, by the time this gets to the FieldCleaningDescriptor
the 'blep' has been converted into True ... fun.
"""
model = DateFieldModel.objects.create(field=date.today())
model.__class__.objects.filter(pk=model.pk).update(field='2000-01-01')
assert model.__class__.objects.get(pk=model.pk).field == date(2000, 1, 1)
def upload_and_rename_picture(instance, filename):
today = date.today()
path = "quiz/{}-{}-{}/".format(
today.year, today.month, today.day) + "".join([
random.choice(string.ascii_letters + string.digits)
for _ in range(20)
])
return path
def age_validator(value):
MIN_AGE = 18
today = date.today()
if (today - value).days < MIN_AGE * 365 + 5:
raise ValidationError({
'email': [
'Account holder must be at least %d years old' % MIN_AGE,
]
})
def test_StrictDateField_form_with_instance_valid():
today = date.today()
future = today + timedelta(days=2)
x = DateFieldModel(field=today)
form_class = modelform_factory(model=DateFieldModel, fields=['field'])
form = form_class(data={'field': future}, instance=x)
assert form.is_valid() is True
assert form.errors == {}
assert form.save().field == future
def create(self, request, *args, **kwargs):
serializer = PageViewCreateSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
url = serializer.data['url']
dt = date.today()
pv, created = self.queryset.get_or_create(url=url, date=dt)
pv.count += 1
pv.save()
return Response(data=self.get_serializer(pv).data)
def validate(self, attrs):
attrs = super(UserSerializer, self).validate(attrs)
birthday = attrs['birthday']
if birthday:
MIN_AGE = 18
today = date.today()
if (today - birthday).days < MIN_AGE * 365 + 5:
raise ValidationError({'email': ['Account holder must be at least %d years old' % MIN_AGE, ]})
return attrs
def vendas_pachamama(request):
queryset = BaseVendasRealizadas.objects.all()
mes_pagamento_vendas = sorted(
set([int(obj.mes_faturamento_2) for obj in queryset]))
produtos_vendas_lista = sorted(
set([str(obj.produto_2) for obj in queryset]))
periodo_vendas = []
produtos_vendas = []
meses = {
'Jan': 1,
'Fev': 2,
'Mar': 3,
'Abr': 4,
'Mai': 5,
'Jun': 6,
'Jul': 7,
'Ago': 8,
'Set': 9,
'Out': 10,
'Nov': 11,
'Dez': 12
}
for i in meses:
data_1 = date.today()
data = '{}-{}'.format(i, data_1.year)
periodo_vendas.append(data)
STATUS = {'status_1': 'Conciliado'}
CLASSIFICACAO_RESULTADO = {
'produtos': '( + ) Produtos',
}
for mes in mes_pagamento_vendas:
cartao_lan = int(
BaseVendasRealizadas.objects.filter(
situacao_faturamento_2=STATUS['status_1'],
classificacao_resultado_faturamento_2=CLASSIFICACAO_RESULTADO[
'produtos'],
mes_faturamento_2=mes,
ano_faturamento_2='2020').aggregate(
Sum('total_mercadoria_2'))['total_mercadoria_2__sum'])
produtos_vendas.append(cartao_lan)
return render(
request, 'pachamama/vendas.html', {
'produtos_vendas': produtos_vendas,
'periodo_vendas': periodo_vendas,
'produtos_vendas_lista': produtos_vendas_lista
})
def add_calendar(title,
content,
type,
url,
is_event,
user=None,
faculty=None,
major=None,
classes=None,
team=None,
show_time=None):
if not show_time:
show_time = date.today()
key_calendar = "%s-%s-%d-%s-%s-%s-%s-%s-%s-%s" % \
(
title, content, type, str(url),
str(getattr(user, "username", "none")),
str(getattr(faculty, "name", "none")),
str(getattr(major, "name", "none")),
str(getattr(classes, "name", "none")),
str(getattr(team, "name", "none")),
str(show_time),
)
key_calendar = hashlib.md5(key_calendar).hexdigest().decode("utf-8")
obj = _calendar_cache_instance.get(key_calendar)
if not obj:
obj = Calendar.objects.filter(title=title,
content=content,
type=type,
url=url,
is_event=is_event,
user=user,
faculty=faculty,
major=major,
classes=classes,
team=team,
show_time=show_time)
if obj:
return
obj = Calendar.objects.create(
title=title,
content=content,
type=type,
url=url,
is_event=is_event,
user=user,
faculty=faculty,
major=major,
classes=classes,
team=team,
)
cache_utils.delete_cache(_calendar_cache_instance)
_calendar_cache_instance.set(key_calendar, obj, settings.DEFAULT_CACHE_AGE)
def dades_basiques(request):
(user, l4) = tools.getImpersonateUser(request)
sessioImpersonada = tools.sessioImpersonada(request)
return {
'data': date.today(),
'user': user,
'l4': l4,
'sessioImpersonada': sessioImpersonada,
'menu': calcula_menu( user, request.path_info ),
}
def list(self, request):
"""
Lists student counts by state and month
:param request:
:return:
"""
states = (
([StudentProfileState.NEW, StudentProfileState.IMPORTED,
StudentProfileState.MISSING_INFORMATION, StudentProfileState.INTERVIEW_SCHEDULED], _('Pending')),
([StudentProfileState.REJECTED, StudentProfileState.OUTBOARDED], _('Rejected or Outboarded')),
([StudentProfileState.ACCEPTED], _('Accepted into Pool')),
)
truncate_date = connection.ops.date_trunc_sql('month', 'auth_user.date_joined')
num_months = 6
start_date = date.today() - relativedelta(months=num_months)
months = [start_date + relativedelta(months=x) for x in range(0, num_months + 1)]
categories = ["%s %s" % (m.strftime('%b'), m.strftime('%y')) for m in months]
columns = []
month_nums = [m.month for m in months]
for keys, label in states:
"""
Count each state and group by month
"""
state_data = [label]
results = StudentProfile.objects.filter(state__in=keys, user__date_joined__isnull=False)\
.extra({'month': truncate_date})\
.annotate(count=Count('id'))\
.values('month', 'count')
results_dict = {}
for r in results:
if r['month'].month in results_dict:
results_dict[r['month'].month] += r['count']
else:
results_dict[r['month'].month] = r['count']
for m in month_nums:
count = 0
if m in results_dict:
count = results_dict[m]
state_data.append(count)
columns.append(state_data)
# Add totals
columns.append(['Total'] + [StudentProfile.objects.filter(
user__date_joined__lt=m,
state=StudentProfileState.ACCEPTED
).count() for m in months])
return Response({'categories': categories, 'columns': columns})
def get_age(self):
today = date.today()
born = self.birthday
try: # raised when birth date is February 29 and the current year is not a leap year
birthday = born.replace(year=today.year)
except ValueError:
birthday = born.replace(year=today.year, day=born.day-1)
except AttributeError:
return 0
if birthday > today:
return today.year - born.year - 1
else:
return today.year - born.year
def resultats( request ):
(user, l4) = tools.getImpersonateUser(request)
professor = User2Professor( user )
report = []
taula = tools.classebuida()
taula.titol = tools.classebuida()
taula.titol.contingut = ""
taula.capceleres = []
capcelera = tools.classebuida()
capcelera.amplade = 35
capcelera.contingut = u'{0}'.format( u'Avaluació qualitativa' )
taula.capceleres.append(capcelera)
capcelera = tools.classebuida()
capcelera.amplade = 65
capcelera.contingut = u'Dades'
taula.capceleres.append(capcelera)
taula.fileres = []
for qualitativa in AvaluacioQualitativa.objects.all():
filera = []
camp = tools.classebuida()
camp.contingut = u'{0}'.format(unicode( qualitativa ) )
filera.append(camp)
camp = tools.classebuida()
obertaLaQualitativa = qualitativa.data_obrir_avaluacio <= date.today() <= qualitativa.data_tancar_avaluacio
estat = '(Oberta)' if obertaLaQualitativa else '(Tancada)'
camp.contingut = u'del {0} al {1} {2}'.format( qualitativa.data_obrir_avaluacio, qualitativa.data_tancar_avaluacio, estat)
camp.enllac = '/avaluacioQualitativa/report/{0}'.format( qualitativa.pk )
filera.append(camp)
taula.fileres.append( filera )
report.append(taula)
return render(
request,
'report.html',
{'report': report,
'head': u'Avaluacions Qualitatives' ,
},
)
def dades_basiques(request):
(user, l4) = tools.getImpersonateUser(request)
sessioImpersonada = tools.sessioImpersonada(request)
my_timeoff = calculate_my_time_off(request.user)
return {
'data': date.today(),
'user': user,
'l4': l4,
'sessioImpersonada': sessioImpersonada,
'menu': calcula_menu( user, request.path_info ),
'my_timeoff': my_timeoff,
'my_safe_timeoff': my_timeoff - 10 if bool(my_timeoff) else my_timeoff,
'es_direccio_o_impersonat': sessioImpersonada or user.groups.filter( name=u"direcció" ),
}
def formatday(self, day, weekday):
if day != 0:
cssclass = self.cssclasses[weekday]
day_date = date(self.year, self.month, day)
if date.today() == day_date:
cssclass += ' today'
if day_date in self.counts:
cssclass += ' filled'
body = ['<ul>']
for item in self.counts[day_date]:
body.append('<li>')
body.append(str(item['dcount']))
body.append('</li>')
body.append('</ul>')
return self.day_cell(cssclass, '<span class="day">%d</span> %s' % (day, ''.join(body)))
return self.day_cell(cssclass, '<span class="day">%d</span>' % day)
return self.day_cell('noday', ' ')
def test_StrictDateField_descriptor_doesnt_disappear():
"""
don't clobber the descriptor
"""
today = date.today()
value = DateFieldModel(field=today)
assert value.field == today
value.field = '2015-04-16'
assert value.field == date(2015, 4, 16)
with pytest.raises(ValidationError):
value.field = 'v'*256
assert value.field == date(2015, 4, 16)
value.field = today
assert value.field == today
with pytest.raises(TypeError):
value.field = -1
with pytest.raises(ValidationError):
value.field = '-1'
def mostraGrupPromocionar(request, grup=""):
from datetime import date
PromoFormset = modelformset_factory(Alumne, form=promoForm, extra = 0)
if request.method == 'POST':
curs_vinent = request.POST.get('curs_desti')
print request.POST
formset = PromoFormset(request.POST)
for form in formset.forms:
if form.is_valid():
decisio = form.cleaned_data['decisio']
if (decisio == "2"):
id = form.cleaned_data['id'].id
alumne = Alumne.objects.get(id=id)
alumne.data_baixa = date.today()
alumne.estat_sincronitzacio = 'DEL'
alumne.motiu_bloqueig = 'Baixa'
alumne.save()
if (decisio == "0"):
id = form.cleaned_data['id'].id
alumne = Alumne.objects.get(id = id)
alumne.grup_id = curs_vinent
alumne.save()
pass
grups = Grup.objects.all().order_by("descripcio_grup")
grup_actual = Grup.objects.get(id=grup)
alumnes = Alumne.objects.filter(grup=grup, data_baixa__isnull = True ).order_by("cognoms")
if (len(alumnes) == 0):
msg = "Aquest grup no te alumnes actualment."
return render(request,'mostraGrupsPromocionar.html', {"grups" : grups, "msg": msg})
formset = PromoFormset(queryset=alumnes)
return render(request,'mostraGrupPromocionar.html', {"grup_actual" : grup_actual, "formset" : formset, "grups":grups})
def user_home(request):
"""Defines the user's home page. Shows a tabular representation of the user's documents"""
user = request.user
year = request.GET.get('year')
if request.GET.get('query'):
# if week is ALL, then create the date
week = request.GET.get('week')
month = request.GET.get('month')
if week == 'All':
filter_date = datetime.strptime(month + ' ' + year, "%m %Y")
user_notes = Note.objects.filter(user_id=user.id, date_due__gte=filter_date,
date_due__lt=filter_date + timedelta(weeks=4))
# else, do some tricks on weeks & months
else:
filter_date = datetime.strptime(month + ' ' + year, "%m %Y")
week_start = filter_date + timedelta(weeks=int(week) - 1)
user_notes = Note.objects.filter(user_id=user.id,
date_due__gte=week_start,
date_due__lt=week_start + timedelta(weeks=1))
else:
user_notes = Note.objects.filter(user_id=user.id)
curr_date = date.today()
week_ago = curr_date - timedelta(days=7)
purged_items = []
# purge 7 days rule
for user_note in user_notes:
if user_note.date_posted.date() < week_ago:
# delete
Note.objects.filter(id=user_note.id).delete()
purged_items.append(user_note.id)
user_notes = user_notes.exclude(id__in=purged_items)
# +1 day rule.
for user_note in user_notes:
if (not user_note.is_cancelled or not user_note.is_done) and user_note.date_due.date() < curr_date:
user_note.date_due = curr_date + timedelta(days=1)
return render(request, 'todolist/list.html',
{'notes': sorted(user_notes, key=lambda note: note.date_posted, reverse=True)})
def note_new(request):
context = RequestContext(request)
if request.method == 'POST':
note_form = NewNoteForm(data=request.POST)
if note_form.is_valid():
new_note = Note()
new_note.text = note_form.cleaned_data['text']
new_note.is_cancelled = False
new_note.is_done = False
new_note.date_posted = date.today()
new_note.date_due = note_form.cleaned_data['date_due']
new_note.save()
return HttpResponseRedirect('/todolist/')
else:
print(note_form.errors)
else:
note_form = NewNoteForm()
return render_to_response('todolist/new_note.html', {'form': note_form}, context)
def task_status(request):
if request.method != "POST":
raise Http404
else:
postdata = request.POST.copy()
id = postdata.get("id", 0)
value = postdata.get("value", "")
if not id:
return HttpResponse("Bad ID")
if not value:
return HttpResponse("Bad value")
task = Task.objects.get(pk=id)
task.status = value
if value == "ended":
task.date_out = date.today()
else:
if task.date_out:
task.date_out = None
task.save()
return HttpResponse("OK")
def NouPost(request):
if request.method == 'POST':
formulariPost = NouPostForm(request.POST)
if formulariPost.is_valid():
autor = request.user
data = str(date.today())
tema = formulariPost.cleaned_data['tema']
titol = formulariPost.cleaned_data['titol']
entrada = formulariPost.cleaned_data['entrada']
post = Post()
post.autor = autor
post.data_publicacio = data
post.entrada = entrada
post.tema = tema
post.titol = titol
post.save()
messages.add_message(request, messages.INFO, 'Post publicat correctament.')
return HttpResponseRedirect('/')
else:
messages.add_message(request, messages.INFO, 'Error publicant el post.')
else:
formulariPost = NouPostForm()
return render(request,'Blog/nouPost.html', {'formulariPost' : formulariPost})
def given_a_transaction(self, text):
t = Transaction(transaction_date=date.today(), currency_date=date.today(), reference=0, account_id=0, value=0, text=text)
return t
def elsMeusAlumnesAndAssignatures( request ):
(user, l4) = tools.getImpersonateUser(request)
professor = User2Professor( user )
report = []
nTaula=0
assignatura_grup = set()
for ca in Impartir.objects.filter( horari__professor = professor ):
if ca.horari.grup is not None:
assignatura_grup.add( (ca.horari.assignatura, ca.horari.grup ) )
for (assignatura, grup,) in assignatura_grup:
taula = tools.classebuida()
taula.codi = nTaula; nTaula+=1
taula.tabTitle = u'{0} - {1}'.format(unicode( assignatura ) , unicode( grup ) )
taula.titol = tools.classebuida()
taula.titol.contingut = ""
capcelera_nom = tools.classebuida()
capcelera_nom.amplade = 25
capcelera_nom.contingut = u'{0} - {1}'.format(unicode( assignatura ) , unicode( grup ) )
capcelera_nIncidencies = tools.classebuida()
capcelera_nIncidencies.amplade = 10
capcelera_nIncidencies.contingut = u'Incidències'
capcelera_assistencia = tools.classebuida()
capcelera_assistencia.amplade = 5
capcelera_assistencia.contingut = u'Assist.'
capcelera_nFaltes = tools.classebuida()
capcelera_nFaltes.amplade = 15
nClasses = Impartir.objects.filter( horari__professor = professor ,
horari__assignatura = assignatura,
horari__grup = grup
).count()
nClassesImpartides = Impartir.objects.filter(
horari__professor = professor ,
horari__assignatura = assignatura,
horari__grup = grup,
dia_impartir__lte = date.today()
).count()
capcelera_nFaltes.contingut = u' ({0}h impartides / {1}h)'.format( nClassesImpartides, nClasses)
capcelera_contacte = tools.classebuida()
capcelera_contacte.amplade = 45
capcelera_contacte.contingut = u'Dades de contacte Tutors.'
taula.capceleres = [capcelera_nom, capcelera_nIncidencies, capcelera_assistencia, capcelera_nFaltes, capcelera_contacte]
taula.fileres = []
for alumne in Alumne.objects.filter(
controlassistencia__impartir__horari__grup = grup,
controlassistencia__impartir__horari__assignatura = assignatura,
controlassistencia__impartir__horari__professor = professor ).distinct().order_by('cognoms'):
filera = []
#-nom--------------------------------------------
camp_nom = tools.classebuida()
camp_nom.enllac = None
camp_nom.contingut = u'{0}'.format( alumne )
filera.append(camp_nom)
#-incidències--------------------------------------------
camp_nIncidencies = tools.classebuida()
camp_nIncidencies.enllac = None
nIncidencies = alumne.incidencia_set.filter(
control_assistencia__impartir__horari__grup = grup,
control_assistencia__impartir__horari__professor = professor,
control_assistencia__impartir__horari__assignatura = assignatura,
tipus__es_informativa = False
).count()
nExpulsions = alumne.expulsio_set.filter(
control_assistencia__impartir__horari__grup = grup,
control_assistencia__impartir__horari__professor = professor,
control_assistencia__impartir__horari__assignatura = assignatura
).exclude(
estat = 'ES'
).count()
camp_nIncidencies.multipleContingut = [ ( u'Incid: {0}'.format( nIncidencies ), None, ),
( u'Expul: {0}'.format( nExpulsions), None, ) ]
filera.append(camp_nIncidencies)
#-Assistencia--------------------------------------------
from django.db.models import Sum, Count
# nFaltes = alumne.controlassistencia_set.filter(
# estat__isnull = False ,
# impartir__horari__assignatura = assignatura
# ).aggregate(
# ausencia = Sum( 'estat__pct_ausencia' ),
# classes = Count( 'estat' )
# )
controls = alumne.controlassistencia_set.filter(
impartir__dia_impartir__lte = datetime.today(),
impartir__horari__grup = grup,
impartir__horari__professor = professor,
impartir__horari__assignatura = assignatura
)
nFaltesNoJustificades = controls.filter( Q(estat__codi_estat = 'F' ) ).count()
nFaltesJustificades = controls.filter( estat__codi_estat = 'J' ).count()
nRetards = controls.filter( estat__codi_estat = 'R' ).count()
nControls = controls.filter(estat__codi_estat__isnull = False ).count( )
camp = tools.classebuida()
camp.enllac = None
tpc = 100.0 - ( ( 100.0 * float(nFaltesNoJustificades + nFaltesJustificades) ) / float(nControls) ) if nControls > 0 else 'N/A'
camp.contingut = u"""{0:.2f}%""".format( tpc ) if nControls > 0 else 'N/A'
filera.append(camp)
camp = tools.classebuida()
camp.enllac = None
contingut = "Controls: {0},F.no J.: {1},F.Just: {2},Retards: {3}".format( nControls, nFaltesNoJustificades , nFaltesJustificades, nRetards)
camp.multipleContingut = [ (c, None,) for c in contingut.split(',') ]
filera.append(camp)
#--
#-nom--------------------------------------------
camp = tools.classebuida()
camp.enllac = None
camp.multipleContingut = [(u'{0} ({1}, {2}, {3})'.format( alumne.rp1_nom,
alumne.rp1_telefon,
alumne.rp1_mobil,
alumne.rp1_correu ), None,),
(u'{0} ({1}, {2}, {3})'.format( alumne.rp2_nom,
alumne.rp2_telefon,
alumne.rp2_mobil,
alumne.rp2_correu ), None,)]
filera.append(camp)
taula.fileres.append( filera )
report.append(taula)
return render(
request,
'reportTabs.html',
{'report': report,
'head': u'Informació alumnes' ,
},
)
def age(self):
"""
Returns an integer of year between birth_date and now
"""
# end_date = in_date if in_date else date.today()
return (date.today() - self.birth_date).days / 365
def test_StrictDateField_save():
x = DateFieldModel(field=date.today())
x.save()
assert model_to_dict(x) == model_to_dict(DateFieldModel.objects.get(pk=x.pk))
def close(self):
self.state = STATE_ARCHIVE
self.closingdate = date.today()
def today(self):
today = date.today()
return today.replace(day=1,
month=int(self.kwargs.get('month', str(today.month))),
year=int(self.kwargs.get('year', str(today.year))))
}
weekdays.append(d)
_date += timedelta(days=1)
return weekdays
def lastweek(day=date.today()):
onthelastsunday = day + timedelta(days=-(date.weekday(day) + 7))
onsunday = day + timedelta(days=-(date.weekday(day)))
return (onthelastsunday, onsunday)
def datedelta2list(d1,d2):
dlist = []
for i in range((d2-d1).days + 1):
dlist.append(d1 + timedelta(days=i))
return dlist
class Weekly():
def __init__(self, sunday, saturday):
self.sunday = sunday
self.saturday = saturday
def workdays(self):
return 5
def workhours(self, hours_of_day):
return self.workdays() * hours_of_day
if __name__ == '__main__':
start,end = lastweek(date.today())
print start,end
def calcula_menu( user , path ):
if not user.is_authenticated():
return
#mire a quins grups està aquest usuari:
al = Group.objects.get_or_create(name= 'alumne' )[0] in user.groups.all()
di = not al and Group.objects.get_or_create(name= 'direcció' )[0] in user.groups.all()
pr = not al and Group.objects.get_or_create(name= 'professors' )[0] in user.groups.all()
pl = not al and Group.objects.get_or_create(name= 'professional' )[0] in user.groups.all()
co = not al and Group.objects.get_or_create(name= 'consergeria' )[0] in user.groups.all()
pg = not al and Group.objects.get_or_create(name= 'psicopedagog' )[0] in user.groups.all()
so = not al and Group.objects.get_or_create(name= 'sortides' )[0] in user.groups.all()
tu = not al and pr and ( User2Professor( user).tutor_set.exists() or User2Professor( user).tutorindividualitzat_set.exists() )
tots = di or pr or pl or co or al or pg
#Comprovar si té missatges sense llegir
nMissatges = user.destinatari_set.filter( moment_lectura__isnull = True ).count()
fa2segons = datetime.now() - timedelta( seconds = 2 )
nMissatgesDelta = user.destinatari_set.filter( moment_lectura__gte = fa2segons ).count()
#Comprovar si té expulsions sense tramitar o cal fer expulsions per acumulació
teExpulsionsSenseTramitar= False
if pr:
professor = User2Professor( user )
teExpulsionsSenseTramitar = professor.expulsio_set.exclude( tramitacio_finalitzada = True ).exists()
#Acumulació Incidències
if settings.CUSTOM_INCIDENCIES_PROVOQUEN_EXPULSIO and not teExpulsionsSenseTramitar:
professional = User2Professional( user )
teExpulsionsSenseTramitar = ( Alumne
.objects
.order_by()
.filter( incidencia__professional = professional,
incidencia__tipus__es_informativa = False,
incidencia__gestionada_pel_tutor = False,
incidencia__es_vigent = True )
.annotate( n = Count( 'incidencia' ) )
.filter( n__gte = 3 )
.exists()
)
#Comprovar si hi ha una qualitativa oberta
hiHaUnaQualitativaOberta = False
if pr:
from aula.apps.avaluacioQualitativa.models import AvaluacioQualitativa
hiHaUnaQualitativaOberta = AvaluacioQualitativa.objects.filter( data_obrir_avaluacio__lte = date.today(),
data_tancar_avaluacio__gte = date.today() ).exists()
menu = { 'items':[], 'subitems':[], 'subsubitems':[], }
try:
nom_path = resolve( path ).url_name
except:
return menu
menu["esalumne"]=al
if al:
alumneuser = AlumneUser.objects.get( id = user.id )
alumne = alumneuser.getAlumne()
menu["nomusuari"]= u"Família de {alumne}".format( alumne=alumne.nom )
else:
menu["nomusuari"]= user.first_name or user.username
try:
menu_id, submenu_id, subsubmenu_id = nom_path.split( '__' )[:3]
except:
return menu
arbre_tutoria = (
("Actuacions", 'tutoria__actuacions__list', tu, None, None ),
("Incidències de Tutor", 'tutoria__incidencies__list', tu, None, None ),
("Justificar", 'tutoria__justificar__pre_justificar', tu, None, None ),
("Cartes", 'tutoria__cartes_assistencia__gestio_cartes', tu, None, None ),
("Alumnes", 'tutoria__alumnes__list', tu, None, None ),
("Assistència", 'tutoria__assistencia__list_entre_dates', tu, None, None ),
("Informe", 'tutoria__alumne__informe_setmanal', tu, None, None ),
("Portal", 'tutoria__relacio_families__dades_relacio_families', tu, None, None ),
("Seguiment", 'tutoria__seguiment_tutorial__formulari', tu, None, None ),
)
if settings.CUSTOM_TUTORS_INFORME:
arbre_tutoria += (
("Impressió Faltes i Incid.", 'tutoria__informe__informe_faltes_incidencies', tu, None, None ),
)
if hasattr(settings, 'CUSTOM_MODUL_SORTIDES_ACTIU' ) and settings.CUSTOM_MODUL_SORTIDES_ACTIU and ( di or pr ):
professor = User2Professor( user )
filtre = [ 'P', 'R', ]
te_sortides_actives = ( Sortida
.objects
.exclude( estat = 'E' )
.filter( estat__in = filtre )
.filter( data_inici__gte = datetime.now() )
.filter( tutors_alumnes_convocats = professor )
.exists()
)
arbre_tutoria += (
("Sortides", 'tutoria__justificarSortida__list', tu, ( u'!', 'info' ) if te_sortides_actives else None, None
),
)
arbre1 = (
#--Consergeria--------------------------------------------------------------------------
('consergeria', 'Consergeria', 'consergeria__missatges__envia_tutors', co, None,
(
("Missatge a tutors", 'consergeria__missatges__envia_tutors', co, None, None ),
("Incidència per retard", 'consergeria__incidencia__onbehalf', co, None, None ),
)
),
#--Aula--------------------------------------------------------------------------
# id, nom vista seg label
('aula', 'Aula', 'blanc__blanc__blanc', pr, teExpulsionsSenseTramitar or hiHaUnaQualitativaOberta ,
(
("Presencia", 'aula__horari__horari', pr, None, None ),
#("Alumnes", 'aula__alumnes__alumnes_i_assignatures', pr, None, None ),
("Alumnes", 'aula__alumnes__blanc', pr, None,
(
("Els meus alumnes", 'aula__alumnes__alumnes_i_assignatures', pr, None),
),
),
("Incidències", 'aula__incidencies__blanc', pr, ( u'!', 'info' ) if teExpulsionsSenseTramitar else None,
(
("Incidències", 'aula__incidencies__les_meves_incidencies', pr, ( u'!', 'info' ) if teExpulsionsSenseTramitar else None),
("Nova Incidència (fora d'aula)", 'aula__incidencies__posa_incidencia', pr, None ),
("Recull Expulsió", 'aula__incidencies__posa_expulsio', pr, None),
),
),
("Matèries", 'aula__materies__blanc', pr, None,
(
("Llistat entre dates", 'aula__materies__assistencia_llistat_entre_dates', pr, None),
("Calculadora UF", 'aula__materies__calculadora_uf', pr, None )
)
),
("Qualitativa", 'aula__qualitativa__les_meves_avaulacions_qualitatives', pr, ( u'!', 'info' ) if hiHaUnaQualitativaOberta else None, None ),
)
),
#--Tutoria--------------------------------------------------------------------------
('tutoria', 'Tutoria', 'tutoria__actuacions__list', tu, None,
arbre_tutoria
),
#--Gestió--------------------------------------------------------------------------
('gestio', 'Gestió', 'gestio__reserva_aula__list', co or pl, None,
(
("Reserva Aula", 'gestio__reserva_aula__list', co or pl, None, None),
("Cerca Alumne", 'gestio__usuari__cerca', co or pl, None, None),
("Cerca Professor", 'gestio__professor__cerca', co or pl, None, None),
)
),
#--psicopedagog--------------------------------------------------------------------------
('psico', 'Psicopedagog', 'psico__informes_alumne__list', pg or di, None,
(
("Alumne", 'psico__informes_alumne__list', pg or di, None, None ),
("Actuacions", 'psico__actuacions__list', pg or di, None, None ),
)
),
#--Coord.Pedag--------------------------------------------------------------------------
('coordinacio_pedagogica', 'Coord.Pedag', 'coordinacio_pedagogica__qualitativa__blanc', di, None,
(
("Qualitativa", 'coordinacio_pedagogica__qualitativa__blanc', di, None,
(
("Avaluacions", 'coordinacio_pedagogica__qualitativa__avaluacions', di , None ),
("Items", 'coordinacio_pedagogica__qualitativa__items', di , None ),
("Resultats", 'coordinacio_pedagogica__qualitativa__resultats_qualitatives', di , None ),
),
),
("Seguiment Tutorial", "coordinacio_pedagogica__seguiment_tutorial__preguntes", di, None, None ),
),
),
#--Coord.Alumnes--------------------------------------------------------------------------
('coordinacio_alumnes', 'Coord.Alumnes', 'coordinacio_alumnes__ranking__list', di, None,
(
("Alertes Incid.", 'coordinacio_alumnes__ranking__list', di, None, None ),
("Alertes Assist.", 'coordinacio_alumnes__assistencia_alertes__llistat', di, None, None ),
("Cartes", 'coordinacio_alumnes__assistencia__cartes', di, None, None ),
("Sancions", 'coordinacio_alumnes__sancions__sancions', di, None, None ),
("Passa llista grup", 'coordinacio_alumnes__presencia__passa_llista_a_un_grup_tria', di, None, None ),
("Impressió Faltes i Incid.", 'coordinacio_alumnes__alumne__informe_faltes_incidencies', di, None, None ),
#[email protected]
("Indicadors", 'coordinacio_alumnes__indicadors__llistat', di, None, None ),
)
),
#--Coord.Profess.--------------------------------------------------------------------------
('professorat', 'Coord.Prof', 'professorat__baixes__blanc', di, None,
(
("Feina Absència", 'professorat__baixes__blanc', di, None,
(
('Posar feina', 'professorat__baixes__complement_formulari_tria', di, None),
('Imprimir feina', 'professorat__baixes__complement_formulari_impressio_tria' ,di, None),
),
),
("Tutors", 'professorat__tutors__blanc', di, None,
(
('Tutors Grups', 'professorat__tutors__tutors_grups', di, None),
('Tutors individualitzat', 'professorat__tutors__tutors_individualitzats', di, None),
),
),
("Professors", 'professorat__professors__list', di, None, None ),
("Estat Tramitació Exp.", 'professorat__expulsions__control_tramitacio', di, None, None ),
),
),
#--Administració--------------------------------------------------------------------------
('administracio', 'Admin', 'administracio__sincronitza__blanc', di, None,
(
("Sincronitza", 'administracio__sincronitza__blanc', di, None,
(
("Alumnes ESO/BAT", 'administracio__sincronitza__esfera', di , None ),
("Alumnes Cicles", 'administracio__sincronitza__saga', di, None),
("Horaris", 'administracio__sincronitza__kronowin', di , None ),
("Aules", 'gestio__aula__assignacomentari', di, None),
("Reprograma", 'administracio__sincronitza__regenerar_horaris', di , None ),
),
),
("Reset Passwd", 'administracio__professorat__reset_passwd', di, None, None ),
("Càrrega Inicial", 'administracio__configuracio__carrega_inicial', di, None, None ),
("Promocions", 'administracio__promocions__llista', di, None, None),
# ("Nou Alumne", 'administracio__alumnes__noualumne', di, None, None),
# Aquesta pantalla encara no té implementada la seva funcionalitat.
# Queda pendent acabar-la, o eliminar-la de l'aplicació.
)
),
#--relacio_families--------------------------------------------------------------------------
('relacio_families', u'Famílies', 'relacio_families__informe__el_meu_informe', al, None,
(
("Informe", 'relacio_families__informe__el_meu_informe', al, None, None ),
("Paràmetres", 'relacio_families__configuracio__canvi_parametres', al, None, None ),
)
),
)
arbre2 = (
#--Varis--------------------------------------------------------------------------
('varis', 'Ajuda i Avisos', 'varis__about__about' if al else 'varis__elmur__veure', tots, nMissatges > 0,
(
("Notificacions", 'varis__elmur__veure', di or pr or pl or co or pg , ( nMissatgesDelta, 'info' if nMissatgesDelta < 10 else 'danger' ) if nMissatgesDelta >0 else None, None ),
("Missatge a professorat o PAS", 'varis__prof_i_pas__envia_professors_i_pas', pr or pl or co, None, None ),
("Avisos de Seguretat", 'varis__avisos__envia_avis_administradors', tots, None, None ),
("About", 'varis__about__about', tots, None, None ),
)
),
)
arbreSortides = ()
if hasattr(settings, 'CUSTOM_MODUL_SORTIDES_ACTIU' ) and settings.CUSTOM_MODUL_SORTIDES_ACTIU and ( di or pr ):
filtre = []
socEquipDirectiu = User.objects.filter( pk=user.pk, groups__name = 'direcció').exists()
socCoordinador = User.objects.filter( pk=user.pk, groups__name__in = [ 'sortides'] ).exists()
#si sóc equip directiu només les que tinguin estat 'R' (Revisada pel coordinador)
if socEquipDirectiu:
filtre.append('R')
#si sóc coordinador de sortides només les que tinguin estat 'P' (Proposada)
if socCoordinador:
filtre.append('P')
n_avis_sortides = ( Sortida
.objects
.exclude( estat = 'E' )
.filter( estat__in = filtre )
.distinct()
.count()
)
n_avis_sortides_meves = ( Sortida
.objects
.filter( estat = 'E' )
.filter( professor_que_proposa__pk = user.pk )
.distinct( )
.count()
)
arbreSortides = (
#--Varis--------------------------------------------------------------------------
('sortides', 'Activitats', 'sortides__meves__list', di or pr, n_avis_sortides + n_avis_sortides_meves> 0,
(
(u"Històric", 'sortides__all__list', di or so, None, None ),
(u"Gestió d'activitats", 'sortides__gestio__list', di or so, ( n_avis_sortides ,'info', ) if n_avis_sortides > 0 else None, None ),
(u"Les meves propostes d'activitats", 'sortides__meves__list', pr, ( n_avis_sortides_meves ,'info', ) if n_avis_sortides_meves > 0 else None, None ),
)
),
)
arbre = arbre1 + arbreSortides + arbre2
for item_id, item_label, item_url, item_condicio, alerta , subitems in arbre:
if not item_condicio:
continue
actiu = ( menu_id == item_id )
item = classebuida()
item.label = item_label
item.url = reverse( item_url )
item.active = 'active' if actiu else ''
item.alerta = alerta
menu['items'].append( item )
if actiu:
for subitem_label, subitem_url, subitem__condicio, medalla, subsubitems in subitems:
if not subitem__condicio:
continue
actiu = ( submenu_id == subitem_url.split('__')[1] )
subitem = classebuida()
subitem.label = safe( subitem_label )
subitem.url = reverse( subitem_url )
subitem.active = 'active' if actiu else ''
if medalla:
omedalla = classebuida()
omedalla.valor = medalla[0]
omedalla.tipus = medalla[1]
subitem.medalla = omedalla
menu['subitems'].append(subitem)
subitem.subsubitems = []
if subsubitems:
for subitem_label, subitem_url, subitem_condicio, subitem_medalla in subsubitems:
subsubitem = classebuida()
subsubitem.label = safe( subitem_label )
subsubitem.url = reverse( subitem_url )
if subitem_medalla:
omedalla = classebuida()
omedalla.valor = subitem_medalla[0]
omedalla.tipus = subitem_medalla[1]
subsubitem.medalla = omedalla
subitem.subsubitems.append(subsubitem)
if actiu and subsubmenu_id == 'blanc':
menu['subsubitems'] = subitem.subsubitems
return menu
def test_end_date_in_event_list_page(self):
d = date.today() + timedelta(days=4)
event = create_event(end_date=d)
rendered_html = self.instance.render_plugin()
self.assertIn(print_date(d, "N j, Y"), rendered_html)
def lastweek(day=date.today()):
onthelastsunday = day + timedelta(days=-(date.weekday(day) + 7))
onsunday = day + timedelta(days=-(date.weekday(day)))
return (onthelastsunday, onsunday)
