347         for user_id_string in post_data:

   350         def parse_form():

   348             id_str_list = user_id_string.split('_')

   351             """Helper function that gets the User ID from the

   349             if (len(id_str_list) == 3 and id_str_list[0] == 'registrant' and

   352             form name

   350               id_str_list[1] == 'id'):

   353             """

   351                 id = int(id_str_list[2])

   354 

   352                 reg_user = User.objects.get(pk=id)

   355             confirmed_ids = []

   353 

   356             acco_ids = []

   354                 payment, created = reg_user.payment_set.get_or_create(

   357             date_ids = {}

   355                   user=reg_user, scope=scope_entity)

   358 

   356 

   359             for name_string in post_data:

   357                 payment.confirmed = True

   360                 id_str_list = name_string.split('_')

   358                 payment.save()

   361                 if (len(id_str_list) == 3 and id_str_list[1] == 'id'):

   359 

   362                     if id_str_list[0] == 'confirmed':

   360                 mail_message = loader.render_to_string(

   363                         confirmed_ids.append(int(id_str_list[2]))

   361                     mail_template,

   364                     if id_str_list[0] == 'acco':

   362                     dictionary={'name': reg_user.get_full_name(),})

   365                         acco_ids.append(int(id_str_list[2]))

   363                 reg_user.email_user(mail_subject, mail_message,

   366                     if id_str_list[0] == 'date':

   364                                     from_email='admin@scipy.in')

   367                         date_str = post_data.get(name_string, None)

   365                 list_user_ids.append(id)

   368                         if date_str:

   366 

   369                             date_ids[int(id_str_list[2])] = post_data.get(

   367         # This is done to unset for the confirmation for users for whom

   370                               name_string, '')

   368         # mistakenly confirmation was set.

   371 

   369         # (TODO) This is a very expensive operation, any better solution

   372             return confirmed_ids, acco_ids, date_ids

   370         # will be appreciated.

   373 

   371         unpaid_users = User.objects.exclude(pk__in=list_user_ids)

   374         confirmed_ids, acco_ids, date_ids = parse_form()

   372         for user in unpaid_users:

   375 

   376         confirmed_users = set(User.objects.filter(id__in=confirmed_ids))

   377         acco_users = set(User.objects.filter(id__in=acco_ids))

   378 

   379         # Users for whom both registration and accommodation is confirmed

   380         for user in confirmed_users & acco_users:

   375             payment.confirmed = False

   383 

   384             payment.confirmed = True

   385             payment.acco_confirmed = True

   386             payment.save()

   387 

   388             if not payment.confirmed_mail and not payment.acco_confirmed_mail:

   389                 mail_message = loader.render_to_string(

   390                   mail_template,

   391                   dictionary={'name': user.get_full_name(),

   392                             'acco': True,

   393                             'reg': True})

   394                 user.email_user(mail_subject, mail_message,

   395                                 from_email='admin@scipy.in')

   396                 payment.confirmed_mail =True

   397                 payment.acco_confirmed_mail = True

   398                 payment.save()

   399 

   400         # Users for whom only registration is confirmed

   401         for user in confirmed_users - acco_users:

   402             payment, created = user.payment_set.get_or_create(

   403               user=user, scope=scope_entity)

   404 

   405             payment.confirmed = True

   406             payment.save()

   407 

   408             if not payment.confirmed_mail:

   409                 mail_message = loader.render_to_string(

   410                   mail_template,

   411                   dictionary={'name': user.get_full_name(),

   412                           'reg': True})

   413                 user.email_user(mail_subject, mail_message,

   414                                 from_email='admin@scipy.in')

   415                 payment.confirmed_mail =True

   416                 payment.save()

   417 

   418         # Users for whom only accommodation is confirmed

   419         for user in acco_users - confirmed_users:

   420             payment, created = user.payment_set.get_or_create(

   421               user=user, scope=scope_entity)

   422 

   423             payment.acco_confirmed = True

   424             payment.save()

   425 

   426             if not payment.acco_confirmed_mail:

   427                 mail_message = loader.render_to_string(

   428                   mail_template,

   429                   dictionary={'name': user.get_full_name(),

   430                           'acco': True})

   431                 user.email_user(mail_subject, mail_message,

   432                                 from_email='admin@scipy.in')

   433                 payment.acco_confirmed_mail = True

   434                 payment.save()

   435 

   436         # Users for whom fee payment date is updated

   437         for id in date_ids:

   438             user = User.objects.get(id=id)

   439             payment, created = user.payment_set.get_or_create(

   440               user=user, scope=scope_entity)

   441 

   442             time_format = "%m/%d/%Y"

   443             date = datetime.datetime.fromtimestamp(time.mktime(

   444               time.strptime(date_ids[id], time_format)))

   445 

   446             payment.date_confirmed = date