def check_permissions(self, request, *args, **kwargs):
# проверяем, что начался новый год и нет распределений
return (
super(StartDistributionYear, self).check_permissions(request, *args, **kwargs)
and get_current_distribution_year() != get_distribution_year()
and not Distribution.objects.active()
)
def get_distribution_statistics_data():
statistic = []
distribution_year = get_current_distribution_year()
distributions = Distribution.objects.filter(
year__year=distribution_year.year)
context = {'distributions_names': [distribution.start_datetime.date()
for distribution in distributions]}
age_groups = AgeGroup.objects.all()
total = [{'number_of_distributed':0, 'places_decision':0}
for age_group in age_groups]
context.update({'age_groups_names': [age_group.name for age_group
in age_groups]})
# проходимся по всем распределениям
for distribution in distributions:
distribution_data = []
# выборка статистики по возрастным группам
for i, age_group in enumerate(age_groups):
vacancies = Vacancies.objects.filter(
distribution=distribution, sadik_group__age_group=age_group)
places_decision = vacancies.filter(
status__in=(VACANCY_STATUS_PROVIDED, VACANCY_STATUS_DISTRIBUTED)).count()
number_of_distributed = vacancies.filter(
status=VACANCY_STATUS_DISTRIBUTED).count()
distribution_data.append(
{'number_of_distributed': number_of_distributed,
'places_decision': places_decision})
total[i]['number_of_distributed'] += number_of_distributed
total[i]['places_decision'] += places_decision
# Накопление итогов
statistic.append(distribution_data)
# добавляем данные об общем количестве
statistic.append(total)
context.update({'statistic': statistic})
return context
def get(self, request, sadik_id):
sadik = get_object_or_404(Sadik, id=sadik_id)
requestions = Requestion.objects.filter(
pref_sadiks=sadik,
status__in=(STATUS_REQUESTER, STATUS_ON_DISTRIBUTION)
)
lowest_category = BenefitCategory.objects.category_without_benefits()
requestions_statistics = {
'prefer_requestions_number': requestions.count(),
'prefer_benefit_requestions_number': requestions.filter(
benefit_category__priority__gt=lowest_category.priority).count()
}
age_groups = AgeGroup.objects.all()
requestions_numbers_by_groups = []
current_distribution_year = get_current_distribution_year()
for group in age_groups:
requestions_numbers_by_groups.append(requestions.filter_for_age(
min_birth_date=group.min_birth_date(
current_distribution_year=current_distribution_year),
max_birth_date=group.max_birth_date(
current_distribution_year=current_distribution_year)
).count())
# список распределенных заявок с путевками в работающие группы этого ДОУ
groups_with_distributed_requestions = sadik.get_groups_with_distributed_requestions()
return self.render_to_response({
'sadik': sadik,
'requestions_statistics': requestions_statistics,
'requestions_numbers_by_groups': requestions_numbers_by_groups,
'groups': age_groups,
'groups_with_distributed_requestions': groups_with_distributed_requestions,
})
def get_context_data(self, **kwargs):
context = super(DistributionYearInfo, self).get_context_data(**kwargs)
context.update({
'current_distribution_year': get_current_distribution_year(),
'not_distributed_requestions_number':
Requestion.objects.enrollment_in_progress().count()})
return context
def post(self, request, sadik_id):
data = json.loads(request.body)
year = get_current_distribution_year()
kg = get_object_or_404(Sadik, pk=sadik_id)
for sg_data in data:
age_group = AgeGroup.objects.get(pk=sg_data['ageGroupId'])
if sg_data['id']:
sadik_group = SadikGroup.objects.get(pk=sg_data['id'])
else:
try:
sadik_group = SadikGroup.objects.get(
sadik=kg, active=True, age_group=age_group)
except ObjectDoesNotExist:
sadik_group = SadikGroup(
sadik=kg, active=True, age_group=age_group, year=year)
sadik_group.set_default_age(age_group)
places = int(sg_data["capacity"])
sadik_group.free_places = places
sadik_group.capacity = places
sadik_group.save()
Logger.objects.create_for_action(
CHANGE_SADIK_GROUP_PLACES,
context_dict={'sadik_group': sadik_group},
extra={
'user': request.user,
'obj': sadik_group,
'age_group': sadik_group.age_group
})
sgs = SadikGroup.objects.filter(active=True, sadik=sadik_id)
return JSONResponse(SadikGroupSerializer(sgs, many=True).data)
def post(self, request):
if request.POST.get('confirmation') == 'yes':
# инициируем зачисление
distribution = Distribution.objects.create(
year=get_current_distribution_year())
distribution.start_datetime = datetime.datetime.now()
distribution.save()
Vacancies.objects.filter(
distribution__isnull=True,
status__isnull=True).update(distribution=distribution)
Logger.objects.create_for_action(
DISTRIBUTION_INIT,
extra={'user': request.user, 'obj': distribution})
# сохраняем изначальный статус
Requestion.objects.filter(status__in=[
STATUS_REQUESTER, STATUS_SHORT_STAY
]).update(previous_status=F('status'))
# обновляем статус на "На распределении"
Requestion.objects.filter(status__in=[
STATUS_REQUESTER, STATUS_SHORT_STAY
]).update(status=STATUS_ON_DISTRIBUTION)
for requestion in Requestion.objects.filter(
status=STATUS_TEMP_DISTRIBUTED):
requestion.change_status(STATUS_ON_TEMP_DISTRIBUTION)
return HttpResponseRedirect(reverse('decision_manager'))
def create_statistic_record(self, type):
from sadiki.statistics.views import STATISTIC_HANDLER_FOR_TYPE
data = json.dumps(STATISTIC_HANDLER_FOR_TYPE[type](), cls=DjangoJSONEncoder)
year = get_current_distribution_year()
statistic_record = self.create(record_type=type,
data=data, year=year)
return statistic_record
def save(self, commit=True):
free_places = self.cleaned_data.get('free_places')
self.instance.capacity = free_places
if not self.initial:
# Создание новой группы
self.instance.year = get_current_distribution_year()
self.instance.min_birth_date = self.cleaned_data['age_group'].min_birth_date()
self.instance.max_birth_date = self.cleaned_data['age_group'].max_birth_date()
return super(SadikGroupForm, self).save(commit)
def create_age_groups_for_sadik(kidgdn):
current_distribution_year = utils.get_current_distribution_year()
for age_group in AgeGroup.objects.all():
group_min_birth_date = age_group.min_birth_date()
group_max_birth_date = age_group.max_birth_date()
SadikGroup.objects.create(
free_places=2,
capacity=2,
age_group=age_group, sadik=kidgdn,
year=current_distribution_year,
min_birth_date=group_min_birth_date,
max_birth_date=group_max_birth_date)
def get_context_data(self, **kwargs):
queryset = kwargs.pop('object_list')
# Отработать форму фильтрации
page_number = self.request.GET.get('page', None)
# Обработать фильтры, если они есть
self.queryset, form = self.process_filter_form(queryset, self.request.GET)
# Разбить на страницы
page_size = self.paginate_by
paginator, page, queryset, is_paginated = self.paginate_queryset(
self.queryset, page_size, page_number)
# для всех заявок получаем возрастные группы, которые подходят для них
age_groups = AgeGroup.objects.all()
current_distribution_year = get_current_distribution_year()
for requestion in queryset:
requestion.age_groups_calculated = requestion.age_groups(
age_groups=age_groups,
current_distribution_year=current_distribution_year)
# для анонимного и авторизованного пользвоателя нужно отобразить какие особые действия совершались с заявкой
requestions_dict = OrderedDict([(requestion.id, requestion) for requestion in queryset])
# нам нужны не все логи, а только с определенными действиями
if queryset:
# если получать логи при пустом queryset, то все упадет, паджинатор возвращает queryset[0:0] с пустым query
logs = Logger.objects.filter(content_type=ContentType.objects.get_for_model(Requestion),
object_id__in=queryset.values_list('id', flat=True), action_flag__in=SPECIAL_TRANSITIONS)
relation_dict = {}
for log in logs:
requestion_log = relation_dict.get(log.object_id)
# если для данной заявки не задан лог или он более старый
if not requestion_log or requestion_log.datetime < log.datetime:
relation_dict[log.object_id] = log
for id, log in relation_dict.items():
requestions_dict[id].action_log = log
context = {
'paginator': paginator,
'page_obj': page,
'is_paginated': is_paginated,
'requestions_dict': requestions_dict,
'form': form,
'target_requestion': self.requestion,
'offset': (page.number - 1) * page_size,
'STATUS_DECISION': STATUS_DECISION,
'import_finished': Preference.objects.filter(
key=PREFERENCE_IMPORT_FINISHED).exists()
}
context.update(kwargs)
return context
def post(self, request):
if request.POST.get('confirmation') == 'yes':
# инициируем зачисление
distribution = Distribution.objects.create(
year=get_current_distribution_year())
Vacancies.objects.filter(distribution__isnull=True,
status__isnull=True).update(distribution=distribution)
Logger.objects.create_for_action(DISTRIBUTION_INIT,
extra={'user': request.user, 'obj': distribution})
Requestion.objects.filter(status=STATUS_REQUESTER).update(
status=STATUS_ON_DISTRIBUTION)
Requestion.objects.filter(status=STATUS_TEMP_DISTRIBUTED).update(
status=STATUS_ON_TEMP_DISTRIBUTION)
Requestion.objects.filter(status=STATUS_WANT_TO_CHANGE_SADIK).update(
status=STATUS_ON_TRANSFER_DISTRIBUTION)
return HttpResponseRedirect(reverse('decision_manager'))
def after_distribution_by_resolution(sender, **kwargs):
transition = kwargs['transition']
request = kwargs['request']
form = kwargs['form']
requestion = kwargs['requestion']
sadik = form.cleaned_data.get('sadik')
sadik.create_default_sadikgroups()
sadik_group = requestion.get_sadik_groups(sadik).filter(
year=get_current_distribution_year())[0]
vacancy = Vacancies.objects.create(
sadik_group=sadik_group, status=VACANCY_STATUS_PROVIDED)
requestion.distributed_in_vacancy = vacancy
requestion.save()
Logger.objects.create_for_action(
transition.index, context_dict=form.cleaned_data,
extra={'user': request.user, 'obj': requestion, },
reason=form.cleaned_data.get('reason'))
def requestions_statistics():
requestions = Requestion.objects.filter(status__in=(STATUS_REQUESTER,
STATUS_ON_DISTRIBUTION))
age_groups = AgeGroup.objects.all()
requestions_numbers_by_groups = []
current_distribution_year = get_current_distribution_year()
for group in age_groups:
requestions_numbers_by_groups.append(
requestions.filter_for_age(min_birth_date=group.min_birth_date(current_distribution_year),
max_birth_date=group.max_birth_date(current_distribution_year)).count())
context = {
'requestions_number': requestions.count(),
'benefit_requestions_number': requestions.filter(
benefit_category__priority__gt=0).count(),
'groups': age_groups,
'requestions_numbers_by_groups': requestions_numbers_by_groups
}
return context
def get_context_data(self, **kwargs):
queryset = kwargs.pop('object_list')
# Отработать форму фильтрации
page_number = self.request.GET.get('page', None)
# Обработать фильтры, если они есть
self.queryset, form = self.process_filter_form(queryset, self.request.GET)
# Разбить на страницы
page_size = self.paginate_by
paginator, page, queryset, is_paginated = self.paginate_queryset(
self.queryset, page_size, page_number)
# для всех заявок получаем возрастные группы, которые подходят для них
age_groups = AgeGroup.objects.all()
current_distribution_year = get_current_distribution_year()
requestions = queryset
for requestion in requestions:
requestion.age_groups_calculated = requestion.age_groups(
age_groups=age_groups,
current_distribution_year=current_distribution_year)
# для анонимного и авторизованного пользователя нужно отобразить
# какие особые действия совершались с заявкой
if requestions:
# если получать логи при пустом queryset, то все упадет,
# паджинатор возвращает queryset[0:0] с пустым query
requestions = add_special_transitions_to_requestions(requestions)
context = {
'paginator': paginator,
'page_obj': page,
'is_paginated': is_paginated,
'requestions': requestions,
'form': form,
'target_requestion': self.requestion,
'offset': (page.number - 1) * page_size,
'STATUS_DECISION': STATUS_DECISION,
'NOT_APPEAR_STATUSES': [STATUS_NOT_APPEAR, ],
'STATUS_DISTIRIBUTED': STATUS_DISTRIBUTED,
'import_finished': Preference.objects.filter(
key=PREFERENCE_IMPORT_FINISHED).exists()
}
context.update(kwargs)
return context
def get(self, request, year=None):
current_distribution_year = get_current_distribution_year().year
years = [year_date.year for year_date in StatisticsArchive.objects.filter(
record_type=self.record_type).order_by('year').dates('year', 'year')]
if current_distribution_year not in years:
years = [current_distribution_year, ] + years
if not year:
year = current_distribution_year
else:
year = int(year)
if year not in years:
raise Http404
if year == current_distribution_year:
context = STATISTIC_HANDLER_FOR_TYPE[self.record_type]()
else:
statistic_record = StatisticsArchive.objects.filter(
record_type=DECISION_STATISTICS, year__year=year)[0]
context = json.loads(statistic_record.data)
context.update({'current_year': year, 'years': years})
return self.render_to_response(context)
def get_queue_data(self, requestion):
before = Requestion.objects.queue().active_queue().requestions_before(requestion)
benefits_before = before.benefits().count()
confirmed_before = before.confirmed().count()
requestions_before = before.count()
benefits_after = Requestion.objects.active_queue().benefits().count() - benefits_before
confirmed_after = Requestion.objects.active_queue().confirmed().count() - confirmed_before
requestions_after = Requestion.objects.active_queue().count() - requestions_before
offset = max(0, requestions_before - 20)
queue_chunk = Requestion.objects.queue().hide_distributed().add_distributed_sadiks()[offset:requestions_before + 20]
queue_chunk = add_special_transitions_to_requestions(queue_chunk)
# Вычесть свою заявку
requestions_after -= 1
if requestion.benefit_category.priority > 0:
benefits_after -= 1
if requestion.status == STATUS_REQUESTER:
confirmed_after -= 1
# для заявок вычисляем возрастные группы
age_groups = AgeGroup.objects.all()
current_distribution_year = get_current_distribution_year()
for req in queue_chunk:
req.age_groups_calculated = req.age_groups(
age_groups=age_groups,
current_distribution_year=current_distribution_year)
return {
'benefits_before': benefits_before,
'benefits_after': benefits_after,
'confirmed_before': confirmed_before,
'confirmed_after': confirmed_after,
'requestions_before': requestions_before,
'requestions_after': requestions_after,
'queue': queue_chunk,
'offset': offset,
}
def queue_info(self):
u"""Собирается информация о очереди"""
info_dict = {}
distribution = Distribution.objects.filter(status=DISTRIBUTION_STATUS_INITIAL)
full_queue = Requestion.objects.queue().confirmed().filter(Q(
status__in=(STATUS_ON_DISTRIBUTION, STATUS_ON_TEMP_DISTRIBUTION),
) | Q(
status=STATUS_DECISION,
distributed_in_vacancy__distribution=distribution
)).select_related('benefit_category')
free_places = SadikGroup.objects.active().aggregate(Sum('free_places'))['free_places__sum']
queue = []
distributed_requestions = Requestion.objects.decision_requestions().filter(
distributed_in_vacancy__distribution=distribution)
if distributed_requestions.exists():
last_distributed_requestion = distributed_requestions.reverse()[0]
else:
last_distributed_requestion = None
distributed_requestions_number = distributed_requestions.count()
current_distribution_year = get_current_distribution_year()
if free_places:
# ищем первую заявку, которая может быть распределена
age_groups = AgeGroup.objects.filter(
sadikgroup__free_places__gt=0).distinct()
# первая, распределяемая заявка
# выставляем в None для дальнейшего сравнения
current_requestion_exp = None
# проходимся по всем группам в которых есть места
for age_group in age_groups:
# фильтруем по возрастной группе
query_for_group = Q(birth_date__lte=age_group.max_birth_date(
current_distribution_year=current_distribution_year)) & \
Q(birth_date__gt=age_group.min_birth_date(
current_distribution_year=current_distribution_year))
# должны быть места в приоритетных ДОУ
query_for_pref_sadiks = Q(
pref_sadiks__groups__free_places__gt=0,
pref_sadiks__groups__age_group=age_group,
pref_sadiks__groups__active=True)
# либо указана возможность зачисления в любой ДОУ и в выбранной
# области есть ДОУ с местами или не указана область
query_for_any_sadiks = Q(
areas__sadik__groups__free_places__gt=0,
areas__sadik__groups__age_group=age_group,
areas__sadik__groups__active=True)
# ищем заявку по приоритетным садикам, сравниваем с первой
requestions_pref_sadiks = full_queue.exclude(
status=STATUS_DECISION).exclude(
admission_date__gt=datetime.date.today(),).filter(
Q(query_for_group & query_for_pref_sadiks))
try:
requestion_pref_sadiks = requestions_pref_sadiks[0]
if current_requestion_exp and (
requestion_pref_sadiks.position_in_queue() <
current_requestion_exp.position_in_queue()):
current_requestion_exp = requestion_pref_sadiks
elif current_requestion_exp is None:
current_requestion_exp = requestion_pref_sadiks
except IndexError:
pass
# ищем заявку по группам ДОУ, сравниваем с первой
requestions_any_sadiks = full_queue.exclude(
status=STATUS_DECISION).exclude(
admission_date__gt=datetime.date.today(),).filter(
Q(query_for_group & query_for_any_sadiks))
try:
requestion_any_sadiks = requestions_any_sadiks[0]
if current_requestion_exp and (
requestion_any_sadiks.position_in_queue() <
current_requestion_exp.position_in_queue()):
current_requestion_exp = requestion_any_sadiks
elif current_requestion_exp is None:
current_requestion_exp = requestion_any_sadiks
except IndexError:
pass
# список заявок, которые могут быть зачислены
if current_requestion_exp:
current_requestion = current_requestion_exp
info_dict.update({'current_requestion': current_requestion,
'location_not_verified': current_requestion.location_not_verified,
'location_form': ChangeLocationForm(instance=current_requestion),
'current_requestion_age_groups': current_requestion.age_groups(
current_distribution_year=current_distribution_year)})
current_requestion_index = full_queue.requestions_before(
current_requestion).count()
if last_distributed_requestion:
last_distributed_index = full_queue.requestions_before(
last_distributed_requestion).count()
inactive_queue = full_queue[last_distributed_index:current_requestion_index]
queue = full_queue[current_requestion_index:current_requestion_index + 10]
else:
inactive_queue = full_queue[:current_requestion_index]
queue = full_queue[current_requestion_index:current_requestion_index + 10]
else:
inactive_queue = []
info_dict.update({'inactive_queue': inactive_queue})
info_dict.update({'distribution': distribution, 'queue': queue,
'free_places': free_places, 'decision_status': STATUS_DECISION,
'last_distributed_requestion': last_distributed_requestion,
'distributed_requestions_number': distributed_requestions_number})
return info_dict
def queue_info(self):
u"""Собирается информация о очереди"""
info_dict = {}
distribution = Distribution.objects.filter(status=DISTRIBUTION_STATUS_INITIAL)
full_queue = Requestion.objects.queue().confirmed().filter(Q(
status__in=(STATUS_ON_DISTRIBUTION, STATUS_ON_TEMP_DISTRIBUTION,
STATUS_ON_TRANSFER_DISTRIBUTION),
) | Q(
status=STATUS_DECISION,
distributed_in_vacancy__distribution=distribution
)).select_related('benefit_category')
free_places = SadikGroup.objects.active().aggregate(Sum('free_places'))['free_places__sum']
queue = []
distributed_requestions = Requestion.objects.decision_requestions().filter(
distributed_in_vacancy__distribution=distribution)
if distributed_requestions.exists():
last_distributed_requestion = distributed_requestions.reverse()[0]
else:
last_distributed_requestion = None
distributed_requestions_number = distributed_requestions.count()
current_distribution_year = get_current_distribution_year()
if free_places:
# ищем первую заявку, которая может быть распределена
age_groups = AgeGroup.objects.filter(sadikgroup__free_places__gt=0
).distinct()
requestions_with_places_query = Q()
# проходимся по всем группам в которых есть места и формируем запрос
for age_group in age_groups:
# фильтруем по возрастной группе
query_for_group = Q(birth_date__lte=age_group.max_birth_date(
current_distribution_year=current_distribution_year)) & \
Q(birth_date__gt=age_group.min_birth_date(
current_distribution_year=current_distribution_year))
# должны быть места в приоритетных ДОУ
query_for_pref_sadiks = Q(pref_sadiks__groups__free_places__gt=0,
pref_sadiks__groups__age_group=age_group,
pref_sadiks__groups__active=True)
# либо указана возможность зачисления в любой ДОУ и в выбранной области есть ДОУ с местами
# или не указана область
query_for_any_sadiks = Q(distribute_in_any_sadik=True) & (
Q(areas__isnull=True) | Q(areas__sadik__groups__free_places__gt=0,
areas__sadik__groups__age_group=age_group,
areas__sadik__groups__active=True))
# собираем все в один запрос
requestions_with_places_query |= query_for_group & (query_for_pref_sadiks | query_for_any_sadiks)
# список заявок, которые могут быть зачислены
requestions_with_places = full_queue.exclude(status=STATUS_DECISION
).exclude(admission_date__gt=datetime.date.today(),
).filter(requestions_with_places_query)
if requestions_with_places.exists():
current_requestion = requestions_with_places[0]
info_dict.update({'current_requestion': current_requestion,
'current_requestion_age_groups': current_requestion.age_groups(
current_distribution_year=current_distribution_year)})
current_requestion_index = full_queue.requestions_before(
current_requestion).count()
if last_distributed_requestion:
last_distributed_index = full_queue.requestions_before(
last_distributed_requestion).count()
inactive_queue = full_queue[last_distributed_index:current_requestion_index]
queue = full_queue[current_requestion_index:current_requestion_index + 10]
else:
inactive_queue = full_queue[:current_requestion_index]
queue = full_queue[current_requestion_index:current_requestion_index + 10]
else:
inactive_queue = []
info_dict.update({'inactive_queue': inactive_queue})
info_dict.update({'distribution': distribution, 'queue': queue,
'free_places': free_places, 'decision_status': STATUS_DECISION,
'last_distributed_requestion': last_distributed_requestion,
'distributed_requestions_number': distributed_requestions_number})
return info_dict
def show_wait_time_statistics():
cursor = connection.cursor()
max_child_age_months = settings.MAX_CHILD_AGE * 12
current_datetime = datetime.datetime.now()
current_distribution_year = get_current_distribution_year()
groups = [{"name": age_group.name, 'short_name': age_group.short_name,
'min_birth_date': age_group.min_birth_date(current_distribution_year),
'max_birth_date': age_group.max_birth_date(current_distribution_year), } for age_group
in AgeGroup.objects.all()]
wait_intervals = []
from_months = 0
for months in xrange(3, max_child_age_months + 1, 3):
interval = {'name': '%s-%s' % (from_months, months - 1),
'from_months': from_months, 'to_months': months, }
wait_intervals.append(interval)
from_months = months
requestions_numbers_by_groups = []
distributed_requestions_numbers_by_groups = []
total_requestions_numbers_by_groups = [0] * len(groups)
# проходим по всем интервалам времени ожидания
for interval in wait_intervals:
from_months = interval['from_months']
to_months = interval['to_months']
requestions_numbers = []
distributed_requestions_numbers = []
# пробегаемся по группам и определяем кол-во заявок
registration_datetime_max = current_datetime - relativedelta(months=from_months)
registration_datetime_min = current_datetime - relativedelta(months=to_months)
for i, group in enumerate(groups):
delta = relativedelta(
current_datetime.date(), group['min_birth_date'])
# если для данной возрастной группы не может быть такого времени ожидания
if from_months > delta.years * 12 + delta.months or (from_months == delta.years * 12 + delta.months
and delta.days == 0):
requestions_numbers.append(None)
distributed_requestions_numbers.append(None)
else:
# подсчитываем кол-во заявок в очереди для данной группы и для данного интервала
cursor.execute("""SELECT COUNT(*) FROM "core_requestion"
WHERE ("core_requestion"."birth_date" > %(min_birth_date)s AND
"core_requestion"."birth_date" <= %(max_birth_date)s) AND
("core_requestion"."registration_datetime" <= %(registration_datetime_max)s AND
"core_requestion"."registration_datetime" > %(registration_datetime_min)s) AND
"core_requestion"."status" IN %(statuses)s
""", {"min_birth_date": group["min_birth_date"], "max_birth_date": group["max_birth_date"],
"registration_datetime_max": registration_datetime_max,
"registration_datetime_min": registration_datetime_min,
"statuses": (STATUS_REQUESTER, STATUS_ON_DISTRIBUTION)})
requestions_number = cursor.fetchone()[0]
requestions_numbers.append(requestions_number)
# для группы прибавляем общее кол-во заявок в ней
total_requestions_numbers_by_groups[i] += requestions_number
# кол-во распределенных заявок
cursor.execute("""SELECT COUNT(*) FROM "core_requestion"
WHERE ("core_requestion"."birth_date" > %(min_birth_date)s AND
"core_requestion"."birth_date" <= %(max_birth_date)s) AND
("core_requestion"."registration_datetime" <=
("core_requestion"."decision_datetime" - interval '%(from_days)s months') AND
"core_requestion"."registration_datetime" >
("core_requestion"."decision_datetime" - interval '%(to_days)s months')) AND
"core_requestion"."status" IN (13, 6, 9, 15, 54, 16, 53)
""", {"min_birth_date": group["min_birth_date"], "max_birth_date": group["max_birth_date"],
"from_days": from_months,
"to_days": to_months,
"statuses": (STATUS_DISTRIBUTED, ) + DISTRIBUTION_PROCESS_STATUSES})
distributed_requestions_number = cursor.fetchone()[0]
distributed_requestions_numbers.append(distributed_requestions_number)
# для данного интервала список кол-ва заявок по группам
requestions_numbers_by_groups.append(requestions_numbers)
distributed_requestions_numbers_by_groups.append(distributed_requestions_numbers)
total_requestions_number = sum(total_requestions_numbers_by_groups)
return {
'requestions_numbers_by_groups': requestions_numbers_by_groups,
'total_requestions_numbers_by_groups': total_requestions_numbers_by_groups,
'wait_intervals': wait_intervals,
'groups': groups,
'total_requestions_number': total_requestions_number,
'json': {
'requestions_numbers_by_groups': simplejson.dumps(requestions_numbers_by_groups),
'distributed_requestions_numbers_by_groups': simplejson.dumps(distributed_requestions_numbers_by_groups),
'wait_intervals': simplejson.dumps(wait_intervals),
},
}
def test_distribution(self):
management.call_command('generate_sadiks', 10)
management.call_command('generate_requestions', 200,
distribute_in_any_sadik=True)
Requestion.objects.all().update(status=STATUS_REQUESTER)
# Requestion.objects.all().update(cast=3)
current_datetime = datetime.date.today()
current_distribution_year = get_current_distribution_year()
for age_group in AgeGroup.objects.all():
group_min_birth_date = age_group.min_birth_date()
group_max_birth_date = age_group.max_birth_date()
for sadik in Sadik.objects.all():
SadikGroup.objects.create(
free_places=10,
capacity=10, age_group=age_group, sadik=sadik,
year=current_distribution_year,
min_birth_date=group_min_birth_date,
max_birth_date=group_max_birth_date)
# группа заявок с датой распределения преывшающей текущую
# они не должны быть распределены
requestions_admission_date_ids = list(Requestion.objects.all(
).order_by('?')[:30].values_list('id', flat=True))
try:
admission_date = current_datetime.replace(
year=current_datetime.year + 1)
except ValueError:
admission_date = current_datetime.replace(
year=current_datetime.year + 1, day=current_datetime.day - 1)
Requestion.objects.filter(
id__in=requestions_admission_date_ids
).update(admission_date=admission_date)
# добавим новые ДОУ без мест и заявки желающие распределиться только
# в эти ДОУ
existing_sadiks_ids = list(Sadik.objects.all().values_list(
'id', flat=True))
management.call_command('generate_sadiks', 5)
new_sadiks = list(Sadik.objects.exclude(id__in=existing_sadiks_ids))
# TODO: Исправить тест, с учетом distribute_in_any_sadik = True!!!
requestions_pref_sadiks_ids = list(Requestion.objects.exclude(
id__in=requestions_admission_date_ids
).order_by('?')[:30].values_list('id', flat=True))
for requestion in Requestion.objects.filter(
id__in=requestions_pref_sadiks_ids):
requestion.pref_sadiks = new_sadiks
requestion.distribute_in_any_sadik = True
requestion.save()
requestions_area_distribution_ids = list(Requestion.objects.exclude(
id__in=requestions_admission_date_ids + requestions_pref_sadiks_ids
)[:30].values_list('id', flat=True))
Requestion.objects.filter(id__in=requestions_area_distribution_ids
).update(distribute_in_any_sadik=True)
for requestion in Requestion.objects.filter(
id__in=requestions_area_distribution_ids):
requestion.areas = (random.choice(Area.objects.all()),)
requestion.pref_sadiks = []
client = Client()
client.login(username=self.operator.username, password="******")
client.post(reverse('distribution_init'), data={'confirmation': 'yes'},
follow=True)
decision_manager = DecisionManager()
last_distributed_requestion = None
queue_info = decision_manager.queue_info()
total = 0
while queue_info['free_places'] and queue_info['queue']:
requestion = queue_info['current_requestion']
if last_distributed_requestion:
self.assertEqual(last_distributed_requestion,
queue_info['last_distributed_requestion'], )
sadiks_for_requestion_dict = decision_manager.sadiks_for_requestion(
requestion)
sadiks_for_requestion = \
sadiks_for_requestion_dict['pref_sadiks'] or \
sadiks_for_requestion_dict['any_sadiks']
sadik = sadiks_for_requestion[0]
if requestion.cast == 1:
response = client.post(
reverse('decision_manager'),
data={
'sadik': sadik.id,
'requestion_id': requestion.id,
'accept_location': True}
)
else:
response = client.post(
reverse('decision_manager'),
data={'sadik': sadik.id, 'requestion_id': requestion.id})
if response.status_code == 302:
last_distributed_requestion = requestion
total += 1
queue_info = decision_manager.queue_info()
# проверяем,что заявки с ЖДП, превышающим текущую дату и желающие
# зачислиться в ДОУ без мест не распределены
# закомментировал с учетом distribute_in_any_sadik = True
requestions_not_decision_ids = list(requestions_admission_date_ids)
# + list(requestions_pref_sadiks_ids)
self.assertEqual(
Requestion.objects.filter(
id__in=requestions_not_decision_ids).filter(
status=STATUS_DECISION).count(), 0)
# проверяем, что заявка была зачислена в свою возрастную группу
for requestion in Requestion.objects.filter(status=STATUS_DECISION):
self.assertIn(
requestion.distributed_in_vacancy.sadik_group.age_group,
requestion.age_groups())
# проверяем, что заявки, которые указали возможность зачисления в
# любой ДОУ были зачислены в нужную территориальную область
for requestion in Requestion.objects.filter(
id__in=requestions_area_distribution_ids,
distributed_in_vacancy__isnull=False):
# проверяем, что заявка попадает в какую-нибудь возрастную группу и
# может быть распределена
if requestion.age_groups():
self.assertEqual(
requestion.areas.all()[0],
requestion.distributed_in_vacancy.sadik_group.sadik.area)
def get_filter_dict(self):
return {
'admission_date__year__lte': get_current_distribution_year().year,
'admission_date__isnull': True,
}
def get_context_data(self, **kwargs):
context = super(DistributionYearInfo, self).get_context_data(**kwargs)
context.update({'current_distribution_year': get_current_distribution_year()})
return context
