\

app/lessons/views.py

@@ -10,7 +10,7 @@
 from app.lessons.utils import lessons_lists, dates_of_lessons_dict, empty_past_lessons, fill_group_by_schedule
 from app.models import Lesson, Group, Payment, StudentInGroup, Attending, Teacher, Student, ScheduleGroup, \
     attending_was_not
-from app.payments.utils import payments_in_month_dicts
+from app.payments.utils import payments_in_month_info
 from app.utils import get_month_name, parse_date_or_none, number_of_month_for_date, start_date_of_month, \
     end_date_of_month, can_user_write_group, days_of_week_names, parse_int_or_none, redirect_back_or_home
 
@@ -98,12 +98,12 @@ def lessons_in_month(group_id, month_number):
                     db.session.add(Attending(lesson=l, student=student_in_group.student, state=new_state))
         flash('посещения и оплата в группе {} за {} сохранены.'.format(group.name, month_name))
         return redirect(url_for('lessons.lessons_in_month', group_id=group_id, month_number=month_number))
-    pd = payments_in_month_dicts(group_id, month_number)
+    pd = payments_in_month_info(group_id, month_number)
     ll = lessons_lists(group_id, month_number)
     return render_template('lessons/lessons_in_month.html', group=group, month_number=month_number,
-                           month_name=month_name, students_in_group=students_in_group, payments=pd[0], confirmed=pd[1],
-                           cash=pd[2], comments=pd[3], lessons=ll[0], attendings_states=ll[1],
-                           write_mode=can_user_write_group(current_user, group))
+                           month_name=month_name, students_in_group=students_in_group, payments=pd.values,
+                           confirmed=pd.confirmed, cash=pd.cash, comments=pd.comments, lessons=ll[0],
+                           attendings_states=ll[1], write_mode=can_user_write_group(current_user, group))
 
 
 @lessons.route('/create/<int:group_id>', methods=['GET', 'POST'])

app/payments/utils.py

@@ -4,53 +4,69 @@
 from app.models import Payment, StudentInGroup, Group
 
 
-# todo: return class.
-def payments_dicts(group):
-    values = dict()
-    confirmed = dict()
-    cash = dict()
-    comments = dict()
-    confirmed_count_months = dict()
-    confirmed_count_students = dict()
-    non_zero_count_months = dict()
-    non_zero_count_students = dict()
+class PaymentsInGroupInfo:
+    def __init__(self):
+        # key in dicts is student_in_group_id.
+        self.values = dict()
+        self.confirmed = dict()
+        self.cash = dict()
+        self.comments = dict()
+        self.confirmed_count_students = dict()
+        self.non_zero_count_students = dict()
+
+        # key in dicts is month_number.
+        self.confirmed_count_months = dict()
+        self.non_zero_count_months = dict()
+
+
+def payments_info(group: Group) -> PaymentsInGroupInfo:
+    result = PaymentsInGroupInfo()
+
     students_in_group = group.students_in_group.all()
     for s in students_in_group:
-        confirmed_count_students[s.id] = 0
-        non_zero_count_students[s.id] = 0
+        result.confirmed_count_students[s.id] = 0
+        result.non_zero_count_students[s.id] = 0
     for m in range(group.start_month, group.end_month + 1):
-        in_month_dicts = payments_in_month_dicts(group.id, m)
-        values[m] = in_month_dicts[0]
-        confirmed[m] = in_month_dicts[1]
-        cash[m] = in_month_dicts[2]
-        comments[m] = in_month_dicts[3]
-        confirmed_count_months[m] = 0
-        non_zero_count_months[m] = 0
+        in_month_dicts = payments_in_month_info(group.id, m)
+        result.values[m] = in_month_dicts.values
+        result.confirmed[m] = in_month_dicts.confirmed
+        result.cash[m] = in_month_dicts.cash
+        result.comments[m] = in_month_dicts.comments
+        result.confirmed_count_months[m] = 0
+        result.non_zero_count_months[m] = 0
         for s in students_in_group:
-            if confirmed.get(m, dict()).get(s.id):
-                confirmed_count_students[s.id] += 1
-                confirmed_count_months[m] += 1
-            if confirmed.get(m, dict()).get(s.id) or values.get(m, dict()).get(s.id, 0) > 0:
-                non_zero_count_students[s.id] += 1
-                non_zero_count_months[m] += 1
-    return [values, confirmed, cash, comments, confirmed_count_months, confirmed_count_students,
-            non_zero_count_months, non_zero_count_students]
+            if result.confirmed.get(m, dict()).get(s.id):
+                result.confirmed_count_students[s.id] += 1
+                result.confirmed_count_months[m] += 1
+            if result.confirmed.get(m, dict()).get(s.id) or result.values.get(m, dict()).get(s.id, 0) > 0:
+                result.non_zero_count_students[s.id] += 1
+                result.non_zero_count_months[m] += 1
+    return result
 
 
-def payments_in_month_dicts(group_id, month_number):
+class PaymentsInGroupInMonthInfo:
+    def __init__(self):
+        # key in dicts is student_in_group_id.
+        self.values = dict()
+        self.confirmed = dict()
+        self.cash = dict()
+        self.comments = dict()
+
+
+def payments_in_month_info(group_id: int, month_number: int) -> PaymentsInGroupInMonthInfo:
+    print(group_id, month_number)
+    result = PaymentsInGroupInMonthInfo()
+
     ps = Payment.query \
         .join(StudentInGroup, StudentInGroup.id == Payment.student_in_group_id) \
         .filter(StudentInGroup.group_id == group_id, Payment.month == month_number)
-    values = dict()
-    confirmed = dict()
-    cash = dict()
-    comments = dict()
+
     for p in ps:
-        values[p.student_in_group_id] = p.value
-        confirmed[p.student_in_group_id] = p.confirmed
-        cash[p.student_in_group_id] = p.cash
-        comments[p.student_in_group_id] = p.comment
-    return [values, confirmed, cash, comments]
+        result.values[p.student_in_group_id] = p.value
+        result.confirmed[p.student_in_group_id] = p.confirmed
+        result.cash[p.student_in_group_id] = p.cash
+        result.comments[p.student_in_group_id] = p.comment
+    return result
 
 
 def get_sum_not_confirmed_by_group(teacher_id):

app/payments/views.py

@@ -5,7 +5,7 @@
 from app.decorators import check_access_group_write
 from app.models import Group, Payment
 from app.payments import payments
-from app.payments.utils import payments_dicts, get_sum_not_confirmed_teacher, get_sum_not_confirmed_by_group
+from app.payments.utils import payments_info, get_sum_not_confirmed_teacher, get_sum_not_confirmed_by_group
 
 
 @payments.route('/group/<int:group_id>', methods=['GET', 'POST'])
@@ -40,16 +40,16 @@ def payments_in_group(group_id):
                                            cash=is_cash, confirmed=can_confirm and is_confirmed, comment=comment))
         flash('оплата в группе {} сохранена.'.format(group.name))
         return redirect(url_for('payments.payments_in_group', group_id=group_id))
-    pd = payments_dicts(group)
+    pd = payments_info(group)
     total_payments = 0
     confirmed_payments = 0
     non_zero_payments = 0
     students_in_month = dict()
     for month_number in range(group.start_month, group.end_month + 1):
         students_count = group.students_in_group_in_month(month_number).count()
         total_payments += students_count
-        confirmed_payments += pd[4][month_number]
-        non_zero_payments += pd[6][month_number]
+        confirmed_payments += pd.confirmed_count_months[month_number]
+        non_zero_payments += pd.non_zero_count_months[month_number]
         students_in_month[month_number] = students_count
     if current_user.is_teacher:
         sum_not_confirmed_by_group = get_sum_not_confirmed_by_group(current_user.teacher.id)
@@ -59,9 +59,12 @@ def payments_in_group(group_id):
         sum_not_confirmed_all = None
     students_in_group = group.students_in_group_by_fio.all()
     return render_template('payments/payments_in_group.html', group=group, students_in_group=students_in_group,
-                           payments=pd[0], confirmed=pd[1], cash=pd[2], comments=pd[3], confirmed_count_months=pd[4],
-                           confirmed_count_students=pd[5], non_zero_count_months=pd[6], non_zero_count_students=pd[7],
-                           total_payments=total_payments, confirmed_payments=confirmed_payments,
-                           non_zero_payments=non_zero_payments, students_in_month=students_in_month,
-                           can_confirm=can_confirm, sum_not_confirmed_by_group=sum_not_confirmed_by_group,
+                           payments=pd.values, confirmed=pd.confirmed, cash=pd.cash, comments=pd.comments,
+                           confirmed_count_months=pd.confirmed_count_months,
+                           confirmed_count_students=pd.confirmed_count_students,
+                           non_zero_count_months=pd.non_zero_count_months,
+                           non_zero_count_students=pd.non_zero_count_students, total_payments=total_payments,
+                           confirmed_payments=confirmed_payments, non_zero_payments=non_zero_payments,
+                           students_in_month=students_in_month, can_confirm=can_confirm,
+                           sum_not_confirmed_by_group=sum_not_confirmed_by_group,
                            sum_not_confirmed_all=sum_not_confirmed_all)