mamweb/personalni/utils.py

import re

from django.contrib.auth.models import AnonymousUser
from django.contrib.auth import get_user_model
from django.contrib.auth.decorators import permission_required, \
	user_passes_test
from django.core.exceptions import ObjectDoesNotExist
from django.db import transaction

from tvorba.models import Rocnik
from .models import *
from soustredeni.models import Konfery_Ucastnici, Soustredeni_Ucastnici
from odevzdavatko.models import Reseni_Resitele
from various.utils import bez_diakritiky_translate


def normalizuj_jmeno(o: Osoba) -> str:
	# FIXME: Možná není potřeba vázat na model?
	cele_jmeno = f'{o.jmeno} {o.prijmeni}'
	cele_jmeno = cele_jmeno.translate(bez_diakritiky_translate)
	cele_jmeno = re.sub(r'[^a-zA-Z- ]', '', cele_jmeno)
	return cele_jmeno

def resi_v_rocniku(rocnik, cislo=None):
	""" Vrátí seznam řešitelů, co vyřešili nějaký problém v daném ročníku, do daného čísla.
	Parametry:
		rocnik (typu Rocnik)	ročník, ze kterého chci řešitele, co něco odevzdali
		cislo (typu Cislo)	číslo, do kterého včetně se počítá, že v daném
					ročníku řešitel něco poslal.
					Pokud není zadané, počítají se všechna řešení z daného ročníku.
	Výstup:
		QuerySet objektů typu Resitel """

	if cislo is None:
		# filtrujeme pouze podle ročníku
		return Resitel.objects.filter(rok_maturity__gte=rocnik.druhy_rok(),
									  reseni__hodnoceni__deadline_body__cislo__rocnik=rocnik).distinct()
	else:  # filtrujeme podle ročníku i čísla
		return Resitel.objects.filter(rok_maturity__gte=rocnik.druhy_rok(),
									  reseni__hodnoceni__deadline_body__cislo__rocnik=rocnik,
									  reseni__hodnoceni__deadline_body__cislo__poradi__lte=cislo.poradi).distinct()


def aktivniResitele(cislo, pouze_letosni=False):
	""" Vrací QuerySet aktivních řešitelů, což jsou ti, co ještě neodmaturovali
	a letos něco poslali (anebo loni něco poslali, pokud jde o první tři čísla).
	Parametry:
		cislo (typu Cislo)	číslo, o které se jedná
		pouze_letosni		jen řešitelé, kteří tento rok něco poslali

	"""
	letos = cislo.rocnik

	# detekujeme, zda jde o první tři čísla či nikoli (tj. zda spamovat řešitele z minulého roku)
	zacatek_rocniku = True
	try:
		if int(cislo.poradi) > 3:
			zacatek_rocniku = False
	except ValueError:
		# if cislo.poradi != '7-8':
		# 	raise ValueError(f'{cislo} je neplatné číslo čísla (není int a není 7-8)')
		zacatek_rocniku = False

	# nehledě na číslo chceme jen řešitele, kteří letos něco odevzdali
	if pouze_letosni:
		zacatek_rocniku = False

	try:
		loni = Rocnik.objects.get(rocnik=letos.rocnik - 1)
	except ObjectDoesNotExist:
		# Pro první ročník neexistuje ročník předchozí
		zacatek_rocniku = False

	if not zacatek_rocniku:
		return resi_v_rocniku(letos, cislo).filter(rok_maturity__gte=letos.druhy_rok())
	else:
		# spojíme querysety s řešiteli loni a letos do daného čísla
		return (resi_v_rocniku(loni) | resi_v_rocniku(letos, cislo)).distinct().filter(rok_maturity__gte=letos.druhy_rok())


org_required = permission_required('auth.org')
resitel_required = permission_required('auth.resitel')


# inspirováno django.contrib.auth.decorators permission_required
def check_perms(user):
	if user.has_perms(('auth.resitel',)):
		return True
	if user.has_perms(('auth.org',)):
		return True
	return False


resitel_or_org_required = user_passes_test(check_perms)

User = get_user_model()
# Není to úplně hezké, ale budeme doufat, že to je funkční...
User.je_org = property(lambda self: self.has_perm('auth.org'))
User.je_resitel = property(lambda self: self.has_perm('auth.resitel'))
AnonymousUser.je_org = False
AnonymousUser.je_resitel = False


def sync_skoly(base_url):
	"""Stáhne všechny školy z mamwebu na adrese <base_url> a uloží je do databáze"""
	from django.urls import reverse
	full_url = base_url.rstrip('/') + reverse('export_skoly')
	import requests
	from django.core import serializers
	json =  requests.get(full_url, stream=True).content
	for skola in serializers.deserialize('json', json):
		skola.save()

@transaction.atomic
def merge_resitele(cilovy, zdrojovy):
	"""Spojí dva řešitelské objekty do cílového.

	Pojmenování "zdrojový" je silně nepřiléhající, ale co už…"""

	# Postup:
	# Sjednotit / upravit informace cílového řešitele
	print('Upravuji data modelu')
	fieldy_shoda = ['skola', 'rok_maturity', 'zasilat', 'zasilat_cislo_emailem', 'zasilat_cislo_papirove']

	for f in fieldy_shoda:
		zf = getattr(zdrojovy, f)
		cf = getattr(cilovy, f)
		if cf == zf:
			print(f' Údaj {f} je shodný ({zf})')
		else:
			if zf is None:
				print(f' Údaj {f} je pouze v cílovém, používám')
				continue
			if cf is None:
				setattr(cilovy, f, zf)
				cilovy.poznamka += f'\nDEBUG: Merge: doplnéný údaj {f} ze zdrojového: {zf}'
				print(f" Přiřazuji {f} ze zdrojového: {zf}")
				continue
			# Jsou fakt různé…
			# FIXME: chybí možnost na vlastní úpravu…
			verdikt = input(f"\n\n Údaj {f} se u řešitele {cilovy} ({cilovy.id}) liší:\n  Zdrojový: {zf}\n  Cílový: {cf}\n Který použít, [z]drojový, [c]ílový? ")
			verdikt = verdikt[0].casefold()
			if verdikt == 'z':
				setattr(cilovy, f, zf)
				cilovy.poznamka += f'\nDEBUG: Merge: pro {f} použit údaj {zf} (zdrojový), nepoužit {cf} (cílový)'
			elif verdikt == 'c':
				cilovy.poznamka += f'\nDEBUG: Merge: pro {f} použit údaj {cf} (cílový), nepoužit {zf} (zdrojový)'
			else: raise ValueError('Špatná odpověď, řešitel pravděpodobně neuložen')
	# poznámku chceme nezahodit…
	cilovy.poznamka += f'\nDEBUG: Merge: Původní poznámka: {zdrojovy.poznamka}'
	print(f' Výsledný řešitel: {cilovy.__dict__}, ukládám')
	cilovy.save()


	# Přepojit všechny vazby ze zdrojového na cílového
	print('Přepojuji vazby')
	# Vazby: Škola (hotovo), Řešení_Řešitelé, Konfery_Účastníci, Soustředění_Účastníci, Osoba (vyřeší se později, nejde přepojit)
	ct = Reseni_Resitele.objects.filter(resitele=zdrojovy).update(resitele=cilovy)
	print(f' Přepojeno {ct} řešení')
	ct = Konfery_Ucastnici.objects.filter(resitel=zdrojovy).update(resitel=cilovy)
	print(f' Přepojeno {ct} konfer')
	ct = Soustredeni_Ucastnici.objects.filter(resitel=zdrojovy).update(resitel=cilovy)
	print(f' Přepojeno {ct} sousů')

	# Teď by na zdrojovém řešiteli nemělo nic viset, smazat ho, pamatujíce si jeho Osobu
	zdrosoba = zdrojovy.osoba
	print(f'Mažu zdrojového řešitele {zdrojovy.__dict__}')
	zdrojovy.delete()
	# Spojit osoby (separátní funkce).
	merge_osoby(cilovy.osoba, zdrosoba)

	input("Potvrdit transakci řešitelů (^C pro zrušení) ")

@transaction.atomic
def merge_osoby(cilova, zdrojova):
	""" Spojí dvě osoby do cílové

	Nehlídá omezení typu "max 1 řešitel na osobu", to by měla hlídat databáze (OneToOneField)."""
	# Sjednocení dat
	print('Sjednocuji data osob')
	# ID, User neřešíme, poznámku vyřešíme separátně.
	fieldy = ['datum_narozeni', 'datum_registrace', 'datum_souhlasu_udaje',
			  'datum_souhlasu_zasilani', 'email', 'foto', 'jmeno', 'mesto',
			  'pohlavi_muz', 'prezdivka', 'prijmeni', 'psc', 'stat', 'telefon', 'ulice']
	for f in fieldy:
		zf = getattr(zdrojova, f)
		cf = getattr(cilova, f)
		if cf == zf:
			print(f' Údaj {f} je shodný ({zf})')
		else:
			if zf is None:
				print(f' Údaj {f} je pouze v cílové, používám')
				continue
			if cf is None:
				setattr(cilova, f, zf)
				cilova.poznamka += f'\nDEBUG: Merge: doplnéný údaj {f} ze zdrojové: {zf}'
				print(f" Přiřazuji {f} ze zdrojové: {zf}")
				continue
			# Jsou fakt různé…
			# FIXME: chybí možnost na vlastní úpravu…
			verdikt = input(f"\n\n Údaj {f} se u osoby {cilova} ({cilova.id}) liší:\n  Zdrojový: {zf}\n  Cílový: {cf}\n Který použít, [z]drojový, [c]ílový? ")
			verdikt = verdikt[0].casefold()
			if verdikt == 'z':
				setattr(cilova, f, zf)
				cilova.poznamka += f'\nDEBUG: Merge: pro {f} použit údaj {zf} (zdrojová), nepoužit {cf} (cílová)'
			elif verdikt == 'c':
				cilova.poznamka += f'\nDEBUG: Merge: pro {f} použit údaj {cf} (cílová), nepoužit {zf} (zdrojová)'
			else: raise ValueError('Špatná odpověď, řešitel pravděpodobně neuložen')
	# poznámku chceme nezahodit…
	cilova.poznamka += f'\nDEBUG: Merge: Původní poznámka: {zdrojova.poznamka}'
	print(f' Výsledná osoba: {cilova.__dict__}, ukládám')
	cilova.save()

	# Vazby: Řešitel, User, Příjemce, Organizátor, Škola.kontaktní_osoba
	print('Přepojuji vazby')
	ct = Skola.objects.filter(kontaktni_osoba=zdrojova).update(kontaktni_osoba=cilova)
	print(f' Přepojeno {ct} kontaktních osob')
	# Ostatní vazby vyřeší OneToOneFieldy, ale někdy nemusí existovat…
	ct = Resitel.objects.filter(osoba=zdrojova).update(osoba=cilova)
	print(f' Přepojeno {ct} řešitelů')
	ct = Prijemce.objects.filter(osoba=zdrojova).update(osoba=cilova)
	print(f' Přepojeno {ct} příjemců')
	ct = Organizator.objects.filter(osoba=zdrojova).update(osoba=cilova)
	print(f' Přepojeno {ct} organizátorů')
	# Uživatelé vedou opačným směrem, radši chceme zkontrolovat, že jsou různí ručně:
	if zdrojova.user != cilova.user:
		# Jeden z nich může být nenastavený…
		if zdrojova.user is None:
			print('Uživatel je již v cílové osobě')
		elif cilova.user is None:
			print('Používám uživatele zdrojové osoby')
			cilova.user = zdrojova.user
		# Teď nemůžeme uložit, protože kolize uživatelů. Ukládat cílovou budeme až po smazání zdrojové.
		else: raise ValueError('Osoby mají obě uživatele, radši padám')

	# Uložení a mazání
	print(f'Mažu zdrojovou osobu {zdrojova.__dict__}')
	zdrojova.delete()
	print(f'Ukládám cílovou osobu {cilova.__dict__}')
	cilova.save()

	input("Potvrdit transakci osob (^C pro zrušení) ")