def test_order_on_nullable(self):
qs = Post.objects.all().order_by('author')
print("QS", qs)
first = qs.first()
self.assertEqual(first, self.post2)
print("1")
second = next_in_order(first, qs)
self.assertEqual(second, self.post3)
print("2")
third = next_in_order(second, qs)
self.assertEqual(third, self.post1)
print("3")
fourth = next_in_order(third, qs)
self.assertEqual(fourth, None)
print("4")
fourth_loop = next_in_order(third, qs, loop=True)
self.assertEqual(fourth_loop, self.post2)
print("5")
prev = prev_in_order(first, qs)
self.assertEqual(prev, None)
print("6")
prev_loop = prev_in_order(first, qs, loop=True)
self.assertEqual(prev_loop, self.post1)
def candidates_image_view(request, ID):
qs = Candidates.objects.all().order_by('pk')
first = qs.first()
last = qs.last()
entry = Candidates.objects.get(id=ID)
coords = entry.Transient_file.coords.replace('(', '').replace(')', '')
# If user is on first image page, previous button keeps them on same page. If they are on last image page, next button keeps them on same page.
if entry.pk == first.pk:
next_entry = next_in_order(entry, qs=qs)
previous_entry = entry
elif entry.pk == last.pk:
next_entry = entry
previous_entry = prev_in_order(entry, qs=qs)
else:
next_entry = next_in_order(entry, qs=qs)
previous_entry = prev_in_order(entry, qs=qs)
next_id = next_entry.pk
previous_id = previous_entry.pk
return render(
request, 'candidates/candidate_images.html', {
'entry': entry,
'next_id': next_id,
'previous_id': previous_id,
'coords': coords
})
def update_details(request, pk):
user_to_update = UserDetail.objects.get(id=pk)
user = UserDetail.objects.get(id=pk)
suppose = 'true'
print("level 1")
if request.method == "POST":
first_name = request.POST['first_name']
last_name = request.POST['last_name']
email = request.POST['email']
user.first_name = first_name
user.last_name = last_name
user.email = email
user.save()
print("user saved")
while suppose == "true":
hash_obj = HashTable.objects.get(user=user)
prev_hash_obj = prev_in_order(hash_obj)
if prev_hash_obj != None:
# print("hi")
prev_hash = prev_hash_obj.current_hash
hash_str = prev_hash + user.first_name + user.last_name + user.email
current_hash = hashlib.md5(hash_str.encode()).hexdigest()
print(hash_obj.user, prev_hash, current_hash, " ", hash_str)
hash_obj.previous_hash = prev_hash
hash_obj.current_hash = current_hash
hash_obj.save()
print("hash object saved in not first node")
user = next_in_order(user)
# print(user)
if user == None:
print(" false in not first node")
suppose = "false"
else:
# print('no prev')
prev_hash = "0"
hash_str = prev_hash + user.first_name + user.last_name + user.email
current_hash = hashlib.md5(hash_str.encode()).hexdigest()
print(hash_obj, prev_hash, current_hash, " ", hash_str)
hash_obj.previous_hash = prev_hash
hash_obj.current_hash = current_hash
hash_obj.save()
print("hash object saved in first node")
user = next_in_order(user)
# print(user)
if user == None:
print(" false in first node")
suppose = "false"
# updating last hash object
last_hash_obj = HashTable.objects.last()
prev_hash_of_last = prev_in_order(last_hash_obj).current_hash
last_hash_obj.previous_hash = prev_hash_of_last
last_hash_obj.save()
print("last hash saved")
return redirect('home')
return render(request, 'update_detail.html', {'user': user_to_update})
class TrackListView(generic.ListView):
model = Track
first = Track.objects.first()
second = next_in_order(first)
prev_in_order(second) == first # True
last = prev_in_order(first, loop=True)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['next_song'] = self.second
context['previous_song'] = self.last
return context
def chapter_page(request, slug, vol, num, page):
try:
vol, num, page = int(vol), float(num), int(page)
except (ValueError, TypeError):
raise Http404
if page == 0:
raise Http404
chapters = {
'all': Chapter.objects.filter(series__slug=slug),
'curr': None,
'prev': None,
'next': None
}
try:
chapters['curr'] = chapters['all'] \
.prefetch_related('pages').get(number=num, volume=vol)
except Chapter.DoesNotExist:
raise Http404
chapters['next'] = next_in_order(chapters['curr'], qs=chapters['all'])
chapters['prev'] = prev_in_order(chapters['curr'], qs=chapters['all'])
all_pages = chapters['curr'].pages.all()
if page > len(all_pages):
raise Http404
return render(request, 'chapter.html', {
'all_chapters': chapters['all'].reverse(),
'curr_chapter': chapters['curr'],
'next_chapter': chapters['next'],
'prev_chapter': chapters['prev'],
'all_pages': all_pages,
'curr_page': all_pages.get(number=page)
})
def blogPost(request, slug):
allPosts = Post.objects.all()
post = Post.objects.filter(slug=slug).first()
next = next_in_order(post)
prev = prev_in_order(post)
# getting comment for above post
comments = BlogComment.objects.filter(post=post, parent=None)
# getting replies
replies = BlogComment.objects.filter(post=post).exclude(parent=None)
replyDict = {}
for reply in replies:
if reply.parent.sno not in replyDict.keys():
replyDict[reply.parent.sno] = [reply]
else:
replyDict[reply.parent.sno].append(reply)
print("replydict is", replyDict)
context = {
'post': post,
'next': next,
'prev': prev,
'comments': comments,
'user': request.user,
'replyDict': replyDict
}
return render(request, "blog/blogPost.html", context)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# context['previous_object'] = prev_in_order(context['empresa'])
# context['next_object'] = next_in_order(context['empresa'])
# custom ordering
emp_id = context['empresa'].id
com_id = context['empresa'].comercial_id
qs = models.Empresa.objects.filter(
comercial=com_id).order_by('razon_social')
newest = qs.get(id=emp_id)
context['previous_object'] = prev_in_order(newest, qs=qs)
context['next_object'] = next_in_order(newest, qs=qs)
context['domicilios'] = context['empresa'].domicilios.filter(
active=True)
context['comunicaciones'] = context['empresa'].comunicaciones.filter(
active=True)
context['contactos'] = context['empresa'].contactos.filter(active=True)
context['actividades'] = context['empresa'].actividades.filter(
active=True)
# context['empresa'].contactos.filter(tipo='movil').filter(active=True)
# cargamos los celulares de los contactos
# for reg in context['contactos']:
# reg.comunicaciones = reg.comunicaciones.filter(tipo='movil').filter(active=True)
return context
def get_object(self, queryset=None):
# can bypass idlist and searchlist with own queryset arg
if not queryset:
queryset = self.get_queryset()
# doesn't matter if it is same user, lazy
travel = self.get_travel_for_request().filter(
loggedin_active_tprotections_q)
# required for next/previous token
queryset = queryset.select_related(
"usercomponent", "usercomponent__user",
"usercomponent__user__spider_info").filter(
usercomponent=self.usercomponent).order_by("priority", "id")
ob = get_object_or_404(
queryset,
(~models.Q(travel_protected__in=travel) |
models.Q(ctype__name__in={"SelfProtection", "TravelProtection"})),
token=self.kwargs["token"])
queryset2 = queryset.exclude(
~models.Q(id=ob.id),
info__contains="\x1eunlisted\x1e",
)
ob.previous_object = prev_in_order(ob, queryset2)
ob.next_object = next_in_order(ob, queryset2)
return ob
def article(request, id):
post = get_object_or_404(Post, id=id)
categories = Category.objects.all()
posts = Post.objects.order_by('-timestamp')
current_post = Post.objects.get(pk=id)
next_post = next_in_order(current_post)
previous_post = prev_in_order(current_post)
form = CommentForm(request.POST or None)
if request.user.is_authenticated:
PostView.objects.get_or_create(user=request.user, post=post)
if request.method == "POST":
if form.is_valid():
form.instance.user = request.user
form.instance.post = post
form.save()
return redirect(reverse("article", kwargs={'id': post.pk}))
context = {
'post': post,
'current_post': current_post,
'next_post': next_post,
'previous_post': previous_post,
'categories': categories,
'posts': posts,
'form': form
}
return render(request, 'article.html', context)
def TOC_update(request, id=None):
print(id)
instance = get_object_or_404(DatafileModel, id=id)
form = TOC_Form(request.POST or None, instance=instance)
# the_next = instance.get_next_by_timestamp()
newest = DatafileModel.objects.all().first()
the_next = next_in_order(instance)
the_prev = prev_in_order(instance)
if form.is_valid():
print("HI")
# form.save()
# data_id = DatafileModel.objects.get(data=instance).id
defecient_selected = form.cleaned_data.get("defecient")
remarks_selected = form.cleaned_data.get("remarks")
new_object = testing_of_controls.objects.create(
defecient=defecient_selected, remarks=remarks_selected, data_id=id)
else:
print(form.errors)
# print(form.non_form_errors())
sampling_id = request.session['sampling_id']
#print(instance.data)
context = {
"sampling_data": sampling.objects.get(pk=sampling_id),
"instance": instance,
"form": form,
"the_prev": the_prev,
"the_next": the_next,
}
return render(request, 'sample_form.html', context)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
qs = Track.objects.all().order_by('id')
current_song = self.get_object()
previous_song = prev_in_order(current_song, qs=qs, loop=True)
next_song = next_in_order(current_song, qs=qs, loop=True)
context['next_song'] = next_song
context['previous_song'] = previous_song
return context
def test_empty_ordering(self):
qs = Category.objects.all()
first = qs.first()
self.assertEqual(first, self.first_category)
second = next_in_order(first, qs)
self.assertEqual(second, self.second_category)
third = next_in_order(second, qs)
self.assertEqual(third, None)
third_loop = next_in_order(second, qs, loop=True)
self.assertEqual(third_loop, self.first_category)
prev = prev_in_order(first, qs)
self.assertEqual(prev, None)
prev_loop = prev_in_order(first, qs, loop=True)
self.assertEqual(prev_loop, self.second_category)
def to_representation(self, instance):
queryset = Blog.objects.order_by('id')
prev_instance = prev_in_order(instance, qs=queryset)
next_instance = next_in_order(instance, qs=queryset)
serialized_instance = super().to_representation(instance)
serialized_prev = self.__serialize_or_None(prev_instance)
serialized_next = self.__serialize_or_None(next_instance)
return {
'instance': serialized_instance,
'prev_instance': serialized_prev,
'next_instance': serialized_next,
}
def project(request, slug):
project = Project.objects.get(slug=slug)
qs = Project.objects.filter(is_visible=True)
next_project = next_in_order(project, loop=True, qs=qs)
prev_project = prev_in_order(project, loop=True, qs=qs)
return render(request, 'project.html', {
"project": project,
"next_project": next_project,
"prev_project": prev_project,
})
def check_data():
all_user_obj = UserDetail.objects.all()
data_tampered = []
error = 0
for count, user in enumerate(all_user_obj):
hash_obj = HashTable.objects.get(user=user)
if count == 0:
previous_hash = '0'
hash_str = previous_hash+user.first_name+user.last_name+user.email
current_hash = hashlib.md5(hash_str.encode()).hexdigest()
# next_hash_obj = next_in_order(hash_obj)
if current_hash != hash_obj.current_hash:
error += 1
data_tampered.append(user)
else:
previous_hash = prev_in_order(hash_obj).current_hash
hash_str = previous_hash+user.first_name+user.last_name+user.email
current_hash = hashlib.md5(hash_str.encode()).hexdigest()
# next_hash_obj = next_in_order(hash_obj)
if current_hash != hash_obj.current_hash:
error += 1
data_tampered.append(user)
if error == 0:
message = "safe"
else:
message = "tampered"
return message
# all_hash_objects = HashTable.objects.all()
# count = 0
# while count <= len(all_hash_objects):
# hash_obj = HashTable.objects.first()
# user = hash_obj.user
# prev_user = prev_in_order(user)
# if prev_user == None:
# previous_hash = '0'
# hash_str = previous_hash+user.first_name+user.last_name+user.email
# current_hash = hashlib.md5(hash_str.encode()).hexdigest()
# if current_hash == hash_obj.current_hash:
# message = "Data Is Safe"
# return message
# else:
# message = "Data Tampering Detected"
# return message
# else:
# previous_hash = prev_user.current_hash
# hash_str = previous_hash+user.first_name+user.last_name+user.email
# current_hash = hashlib.md5(hash_str.encode()).hexdigest()
def test_default(self):
qs = Post.objects.all()
first = qs.first()
self.assertEqual(first, self.post1)
second = next_in_order(first)
self.assertEqual(second, self.post2)
third = next_in_order(second)
self.assertEqual(third, self.post3)
fourth = next_in_order(third)
self.assertEqual(fourth, None)
fourth_loop = next_in_order(third, loop=True)
self.assertEqual(fourth_loop, self.post1)
prev = prev_in_order(first)
self.assertEqual(prev, None)
prev_loop = prev_in_order(first, loop=True)
self.assertEqual(prev_loop, self.post3)
def test_custom(self):
qs = Post.objects.all().order_by('category__title', '-created')
first = qs.first()
self.assertEqual(first, self.post3)
second = next_in_order(first, qs)
self.assertEqual(second, self.post1)
third = next_in_order(second, qs)
self.assertEqual(third, self.post2)
fourth = next_in_order(third, qs)
self.assertEqual(fourth, None)
fourth_loop = next_in_order(third, qs, loop=True)
self.assertEqual(fourth_loop, self.post3)
prev = prev_in_order(first, qs)
self.assertEqual(prev, None)
prev_loop = prev_in_order(first, qs, loop=True)
self.assertEqual(prev_loop, self.post2)
def image_view(request, field_ID, ID):
qs = Transient_files.objects.filter(field_ID__field_ID=field_ID).order_by(
'mag_1', 'pk')
first = qs.first()
last = qs.last()
entry = Transient_files.objects.get(id=ID)
coords = entry.coords.replace('(', '').replace(')', '')
# If user is on first image page, previous button keeps them on same page. If they are on last image page, next button keeps them on same page.
if entry.pk == first.pk:
next_entry = next_in_order(entry, qs=qs)
previous_entry = entry
elif entry.pk == last.pk:
next_entry = entry
previous_entry = prev_in_order(entry, qs=qs)
else:
next_entry = next_in_order(entry, qs=qs)
previous_entry = prev_in_order(entry, qs=qs)
next_id = next_entry.pk
previous_id = previous_entry.pk
""" If user clicks Add button, then pk of post should be saved to 'candidates' list"""
if request.POST.get('pair_id') == 'Add':
candidate_list.append(entry.pk)
if request.POST.get('pair_id') == 'Remove':
candidate_list.remove(entry.pk)
return render(
request, 'vetting/images.html', {
'entry': entry,
'next_id': next_id,
'previous_id': previous_id,
'coords': coords,
'candidate_list': candidate_list
})
def get_context_data(self, **kwargs):
context = super(CryptocurrencyDetailView,
self).get_context_data(**kwargs)
context['next'] = next_in_order(self.object)
context['prev'] = prev_in_order(self.object)
if not self.object.website and self.request.GET.get('refresh'):
try:
page = requests.get('https://coinmarketcap.com/currencies/' +
self.object.slug + '/')
soup = BeautifulSoup(page.text, 'html.parser')
coin = self.get_object()
coin.website = soup.find('span', {
'title': 'Website'
}).findNext('a').get('href')
coin.save()
except:
pass
if not self.object.website_screenshot and self.request.GET.get(
'refresh'):
try:
from selenium import webdriver
driver = webdriver.PhantomJS()
driver.set_window_size(1120, 550)
driver.get(self.object.website)
driver.get_screenshot_as_file('media\website_screenshots\/' +
self.object.slug + '.png')
screenshot = driver.get_screenshot_as_png()
driver.quit()
img = Image.open(BytesIO(screenshot))
box1 = (0, 0, 1120, 800)
box2 = (255, 182)
img = img.crop(box1)
img = img.resize(box2)
buffer_ = BytesIO()
img.save(buffer_, 'PNG')
content_file = ContentFile(buffer_.getvalue())
coin = self.get_object()
coin.website_screenshot.save(self.object.slug + '.png',
content_file,
save=True)
except Exception as error:
print(error)
return context
def TOC_update(request, id=None):
sampling_id = request.session['sampling_id']
sampling_data = sampling.objects.get(pk=sampling_id)
instance = get_object_or_404(DatafileModel, id=id)
form = TOC_Form(request.POST or None, request.FILES, instance=instance)
# the_next = instance.get_next_by_timestamp()
cycle = sampling_data.Cycle
client = sampling_data.Client
newest = DatafileModel.objects.filter(cycle=cycle).filter(
client=client).order_by('-id')[:10].first()
the_next = next_in_order(instance)
the_prev = prev_in_order(instance)
submitted = False
sampling_id = request.session['sampling_id']
sampling_data = sampling.objects.get(pk=sampling_id)
if form.is_valid() and request.method == "POST":
# data_id = DatafileModel.objects.get(data=instance).id
new_object = testing_of_controls.objects.filter(data=instance).first()
if not new_object:
new_object = testing_of_controls()
new_object.data = instance
new_object.cycle = sampling_data.Cycle
new_object.client = sampling_data.Client
new_object.deficient = form.cleaned_data.get("deficient")
new_object.remarks = form.cleaned_data.get("remarks")
new_object.save()
submitted = True
success_url = request.get_full_path()
procedures = Test_of_Controls.objects.all()[:5]
context = {
"sampling_data": sampling_data,
"instance": instance,
"form": form,
"submitted": submitted,
"procedures": procedures,
"the_prev": the_prev,
"the_next": the_next,
}
return render(request, 'sample_form.html', context)
def next(self, request):
m = DailyLotto.objects.filter(lotto_type='D').order_by('-end_date')
last = m[2]
second_oldest = prev_in_order(last, m)
n = DailyLottoTicket.objects.filter(daily_lotto=second_oldest)
winners = n.filter(hits__gte=3).order_by('-hits')
# place them on a list
z = []
details = {
'draw_date': second_oldest.end_date,
'jackpot': second_oldest.jack_pot,
'n1': second_oldest.win1,
'n2': second_oldest.win2,
'n3': second_oldest.win3,
'n4': second_oldest.win4,
'n5': second_oldest.win5,
'n6': second_oldest.win6,
'6prize': n.filter(hits=6).count(),
'5prize': n.filter(hits=5).count(),
'4prize': n.filter(hits=4).count(),
'3prize': n.filter(hits=3).count()
}
for winner in winners:
username = winner.player_name.username
tk = {
'name': username,
'ticket_no': winner.ticket_no,
'hits': winner.hits
}
z.append(tk.copy())
return Response({
'response': details,
'past_winners': z
},
status=status.HTTP_200_OK)
def news_detail(request, slug):
context = {}
try:
news = News.objects.filter(active=True, slug=slug)
post_news = News.objects.get(active=True, slug=slug)
except:
post_news = None
raise Http404()
if news and post_news:
cache_key = 'trend_news_detail'
cache_time = 60 * 10
trends = cache.get(cache_key)
try:
similar_news = News.objects.filter(active=True,sub_category=post_news.sub_category).exclude(slug=slug).order_by("-id")[:5].values("title","slug","image","category__title","category__slug","user__username","spot","date","user__profile__image","detail","video_url")
except:
similar_news = None
if not trends:
trends = News.objects.filter(active=True).order_by("-viewed")[:4].values("title","slug","date","image","category__title")
cache.set(cache_key, trends, cache_time)
paging_ch = int(SiteSettings.objects.all().get().post_detail)
sayfa = int(request.GET.get("sayfa", 1))
context = {
'news': news,
'char': paging_ch,
'next_news': next_in_order(post_news),
'prev_news': prev_in_order(post_news, loop=True),
'similar_news': similar_news,
'detailtext': post_news.detail[((sayfa - 1) * paging_ch):(((sayfa - 1) * paging_ch) + paging_ch)],
'comments': NewsComment.objects.filter(parent__in=News.objects.filter(slug=slug), active=True),
'trends': trends,
'gallery': NewsGallery.objects.filter(parent=post_news, active=True),
'site': get_site_config(),
'reklam':reklamlar()
}
if request.method == "POST":
try:
if not request.user.is_authenticated:
NewsComment.objects.create(user=request.POST.get("name"), parent=post_news, content=request.POST.get("content"),active=False, mail=request.POST.get("email"), web_site=request.POST.get("url"))
else:
NewsComment.objects.create(user=request.user.username,parent=post_news,
content=request.POST.get("content"), active=False,
mail=request.user.email, web_site=request.POST.get("url"))
messages.add_message(request, messages.SUCCESS, "Yorum eklendi . Yönetici onayından sonra burada görebilirsiniz")
except:
pass
else:
if post_news:
post_news.viewed += 1
post_news.save()
#yüklenen haberler
numbers_list = News.objects.filter(active=True,sub_category=post_news.sub_category).exclude(id=post_news.id).order_by("-id")[:100]
page = request.GET.get('page', 1)
paginator = Paginator(numbers_list, 1)
try:
numbers = paginator.page(page)
except PageNotAnInteger:
numbers = paginator.page(1)
except EmptyPage:
numbers = paginator.page(paginator.num_pages)
context.update({'numbers':numbers})
return render(request, "haberler/news_detail.html", context)
def symptom_question(request, symptom_name_slug):
if request.method == "GET":
context_dict = {}
try:
symptom = models.Symptom.objects.get(slug=symptom_name_slug)
context_dict["symptom"] = symptom
context_dict["prev_symptom"] = (
None if symptom == models.Symptom.objects.filter(
symptom_type=symptom.symptom_type).first() else
prev_in_order(symptom))
context_dict["response_form"] = get_response_form(
symptom.answer_type)()
except models.Symptom.DoesNotExist:
context_dict["symptom"] = context_dict["response_form"] = None
return render(request,
"sleep_app/symptom_question.html",
context=context_dict)
else:
# clicking on the link to the form sends a POST request to this page. That causes a new person object to be generated
if "first" in request.POST:
create_person_and_id(request)
return redirect(
reverse(
"sleep_app:symptom_form",
kwargs={"symptom_name_slug": symptom_name_slug},
))
else:
try:
symptom = models.Symptom.objects.get(slug=symptom_name_slug)
response_form = get_response_form(symptom.answer_type)(
request.POST)
if response_form.is_valid():
if symptom.answer_type == "bool":
response = models.Response(
symptom=symptom,
bool_response=response_form.
cleaned_data["bool_response"],
)
elif symptom.answer_type == "text":
response = models.Response(
symptom=symptom,
text_response=response_form.
cleaned_data["text_response"],
)
else:
response = models.Response(
symptom=symptom,
scale_response=response_form.
cleaned_data["scale_response"],
)
response.save()
# for some reason we got here through a page with an invalid symptom slug. Should never happen.
except models.Symptom.DoesNotExist:
print(
f"ERROR: Symptom with slug {symptom_name_slug} does not exist."
)
return redirect("sleep_app:main_form_page")
try:
current_person = models.Person.objects.get(
id=request.session["person"])
# user has answered this question before (used the "previous" button). Delete the old answer
old_answer = current_person.answerset_set.filter(
response__symptom=symptom)
if old_answer.count() > 0:
old_answer.first().delete()
answer_set = models.AnswerSet(person=current_person,
response=response)
answer_set.save()
except models.Person.DoesNotExist:
print(
f"ERROR: Person with id {request.session['person']} does not exist"
)
return redirect("sleep_app:main_form_page")
return redirect(
"sleep_app:location" if symptom == models.Symptom.objects.
filter(symptom_type=symptom.symptom_type).last() else reverse(
"sleep_app:symptom_form",
kwargs={"symptom_name_slug": next_in_order(symptom).slug},
))
def previous(self):
return prev_in_order(self)
def recalc_debt_strucure(agreement_id):
"""Пересчёт структуры долга после платежа с записью в базу данных"""
a = Agreement.objects.filter(id=agreement_id).first()
payments = Payment.objects.filter(agreement=a).order_by('created', 'id')
if len(payments) == 0:
a.current_court_costs = a.court_costs
a.current_main_debt = a.main_debt
a.current_percent = a.percent
a.current_commission = a.commission
a.current_penalty = a.penalty
a.current_penalty_agreement = a.penalty_agreement
a.current_debt = a.court_costs + a.main_debt + a.percent + a.commission + a.penalty
a.save()
return
i = 0
for pay in payments:
i += 1
remains = pay.amount
if i == 1:
court_costs = a.court_costs
percent = a.percent
commission = a.commission
penalty = a.penalty
main_debt = a.main_debt
penalty_agreement = a.penalty_agreement
start_court_costs = a.court_costs
start_main_debt = a.main_debt
start_percent = a.percent
start_commission = a.commission
start_penalty = a.penalty
start_penalty_agreement = a.penalty_agreement
else:
last_p = prev_in_order(pay, qs=payments)
court_costs = last_p.end_court_costs
percent = last_p.end_percent
commission = last_p.end_commission
penalty = last_p.end_penalty
penalty_agreement = last_p.end_penalty_agreement
main_debt = last_p.end_main_debt
start_court_costs = last_p.end_court_costs
start_main_debt = last_p.end_main_debt
start_percent = last_p.end_percent
start_commission = last_p.end_commission
start_penalty = last_p.end_penalty
start_penalty_agreement = last_p.end_penalty_agreement
if court_costs > 0:
remains, court_costs = decrease_debt(remains, court_costs)
print('[i] remains after costs = ', remains)
if remains > 0 and penalty > 0:
remains, penalty = decrease_debt(remains, penalty)
print('[i] remains after penalty = ', remains)
if remains > 0 and penalty_agreement > 0:
remains, penalty_agreement = decrease_debt(remains,
penalty_agreement)
print('[i] remains after penalty_agreement = ', remains)
if remains > 0 and commission > 0:
remains, commission = decrease_debt(remains, commission)
print('[i] remains after commission = ', remains)
if remains > 0 and percent > 0:
remains, percent = decrease_debt(remains, percent)
print('[i] remains after percent = ', remains)
if remains > 0:
main_debt = main_debt - remains
pay.start_court_costs = start_court_costs
pay.start_main_debt = start_main_debt
pay.start_percent = start_percent
pay.start_commission = start_commission
pay.start_penalty = start_penalty
pay.start_penalty_agreement = start_penalty_agreement
pay.end_court_costs = court_costs
pay.end_main_debt = main_debt
pay.end_percent = percent
pay.end_commission = commission
pay.end_penalty = penalty
pay.end_penalty_agreement = penalty_agreement
pay.save()
a.current_court_costs = court_costs
a.current_main_debt = main_debt
a.current_percent = percent
a.current_commission = commission
a.current_penalty = penalty
a.current_debt = court_costs + main_debt + percent + commission + penalty + penalty_agreement
a.save()
def get_prev_id(self, obj):
_prev = prev_in_order(obj)
if _prev is not None and _prev.album.keep_private != True:
return _prev.id
return None
