def szr_notice(uid):
text = ''
res = Proceedings.objects.filter(uid=uid, notify=True).order_by('desc', 'id')
if res:
text = 'V těchto soudních řízeních, která sledujete, došlo ke změně:\n\n'
for proc in res:
desc = ' ({})'.format(proc.desc) if proc.desc else ''
text += ' - {}, sp. zn. {}{}\n'.format(
proc.court, composeref(proc.senate, proc.register, proc.number, proc.year), desc)
if proc.court_id != SUPREME_ADMINISTRATIVE_COURT:
court_type = 'ns' if proc.court_id == SUPREME_COURT else 'os'
text += ' {}\n\n'.format(ROOT_URL + GET_PROC.format(
proc.court.id,
proc.court.reports.id if proc.court.reports
else proc.court.id,
proc.senate,
quote(proc.register.upper()),
proc.number,
proc.year,
court_type))
elif proc.auxid:
text += ' {}\n\n'.format(NSS_GET_PROC.format(proc.auxid))
proc.notify = False
proc.save()
LOGGER.info('Non-empty notice prepared for user "{}" ({:d})'.format(User.objects.get(pk=uid).username, uid))
return text
def doc(request, filename):
LOGGER.debug('Document accessed: {}'.format(filename), request)
pathname = join(BASE_DIR, filename).encode('utf-8')
if not isfile(pathname):
raise Http404
mimetype = guess_type(filename, strict=False)[0] or '(neznámý)'
mtime = datetime.fromtimestamp(
getmtime(pathname)).strftime('%d.%m.%Y %H:%M:%S')
docinfo = {
'filename': filename,
'path': split(filename)[0],
'basename': basename(filename),
'mimetype': mimetype,
'mtime': mtime,
'url': getdocurl(filename),
}
return render(request, 'doc.xhtml', {
'page_title': 'Archivovaný dokument',
'docinfo': docinfo
})
def cron_delerr():
Vec.objects.filter(druhStavRizeni=DruhStavRizeni.objects.get(
desc='MYLNÝ ZÁP.')).delete()
Discovered.objects.filter(timestamp_add__lt=datetime.now() -
timedelta(days=10)).delete()
LOGGER.debug('Erroneous proceedings deleted')
def dir_check(osoba, vec):
for debtor in Debtor.objects.all():
date_birth = osoba.datumNarozeni
if date_birth:
date_birth = date_birth.date()
if ((not debtor.court or debtor.court == osoba.idOsobyPuvodce)
and text_opt(debtor.name, osoba.nazevOsoby, debtor.name_opt)
and text_opt(debtor.first_name, osoba.jmeno, debtor.first_name_opt)
and (not debtor.genid or debtor.genid == osoba.ic)
and (not debtor.taxid or icmp(debtor.taxid, osoba.dic))
and (not debtor.birthid or debtor.birthid == osoba.rc)
and (not debtor.date_birth or debtor.date_birth == date_birth)
and (not debtor.year_birth_from or debtor.year_birth_from <= date_birth.year)
and (not debtor.year_birth_to or debtor.year_birth_to >= date_birth.year)):
if Discovered.objects.update_or_create(
uid_id=debtor.uid_id,
desc=debtor.desc,
vec=vec)[1]:
if debtor.uid.email:
Debtor.objects.filter(id=debtor.id).update(notify=True)
LOGGER.info(
'New debtor "{}" detected for user "{}" ({:d})'.format(
debtor.desc,
User.objects.get(pk=debtor.uid_id).username,
debtor.uid_id))
def about(request):
LOGGER.debug('About page accessed', request)
server_version = connection.pg_version
env = (
{
'name': 'Python',
'version': python_version()
},
{
'name': 'Django',
'version': django_version()
},
{
'name':
'PostgreSQL',
'version':
'{:d}.{:d}.{:d}'.format(server_version // 10000,
(server_version // 100) % 100,
server_version % 100)
},
{
'name': 'Platforma',
'version': '{0}-{2}'.format(*uname())
},
)
return render(request, 'about.xhtml', {
'page_title': 'O aplikaci',
'apps': getappinfo(),
'env': env
})
def transdel(request, idx=0):
LOGGER.debug(
'Transaction delete page accessed using method {}, id={}'.format(request.method, idx),
request,
request.POST)
idx = int(idx) - 1
debt = getdebt(request)
if not debt: # pragma: no cover
return error(request)
if idx >= len(debt.transactions):
raise Http404
if request.method == 'GET':
return render(
request,
'hjp_transdel.xhtml',
{'app': APP,
'page_title': 'Smazání transakce',
'date': debt.transactions[idx].date})
else:
button = getbutton(request)
if button == 'yes':
del debt.transactions[idx]
if not setdebt(request, debt): # pragma: no cover
return error(request)
return redirect('hjp:transdeleted')
return redirect('hjp:mainpage')
def home(request):
LOGGER.debug('Home page accessed', request)
grps = [
{
'title': 'Jednoduché výpočty',
'apps': convappinfo(['sop', 'lht', 'cin', 'dvt', 'cnb', 'kos'])
},
{
'title': 'Komplexní výpočty',
'apps': convappinfo(['knr', 'hjp', 'hsp'])
},
{
'title': 'Prohlížení databasí',
'apps': convappinfo(['psj', 'uds', 'udn', 'pir'])
},
{
'title': 'Sledování',
'apps': convappinfo(['szr', 'sur', 'sir', 'dir'])
},
]
return render(request, 'home.xhtml', {
'page_title': 'Právnické výpočty',
'grps': grps,
'suppress_home': True
})
def stat():
from django.contrib.auth.models import User
from legal.common.utils import LOGGER
from legal.common.models import PwResetLink, Preset, Cache, Asset
now = datetime.now()
LOGGER.debug('Partial statistics generated')
return (
(
'Počet uživatelů',
User.objects.count()),
(
'Počet nových uživatelů za posledních 24 hodin',
User.objects.filter(date_joined__gte=(now - timedelta(hours=24))).count()),
(
'Počet nových uživatelů za poslední týden',
User.objects.filter(date_joined__gte=(now - timedelta(weeks=1))).count()),
(
'Počet nových uživatelů za poslední měsíc',
User.objects.filter(date_joined__gte=(now - timedelta(days=30))).count()),
(
'Počet dočasných linků pro obnovení hesla',
PwResetLink.objects.count()),
(
'Počet záznamů v tabulce Preset',
Preset.objects.count()),
(
'Počet položek v tabulce Cache',
Cache.objects.count()),
(
'Počet položek v tabulce Asset',
Asset.objects.count()),
)
def htmllist(request):
LOGGER.debug('HTML list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
start = int(reqd['start']) if 'start' in reqd else 0
assert start >= 0
res = Hearing.objects.filter(**par).order_by('-time', 'pk').distinct()
except:
raise Http404
total = res.count()
if total and start >= total:
start = total - 1
return render(
request,
'psj_list.xhtml',
{'app': APP,
'page_title': 'Výsledky vyhledávání',
'rows': res[start:start + BATCH],
'pager': Pager(start, total, reverse('psj:htmllist'), reqd, BATCH),
'today': date.today(),
'total': total,
'NULL_REGISTERS': NULL_REGISTERS,
'noindex': True})
def stat(request):
LOGGER.debug('Statistics page accessed', request)
return render(request, 'stat.xhtml', {
'page_title': 'Statistické údaje',
'apps': getappstat(),
})
def pwchange(request):
LOGGER.debug(
'Password change page accessed using method {}'.format(request.method),
request, request.POST)
var = {'page_title': 'Změna hesla'}
user = request.user
uid = user.id
username = request.user.username
if request.method == 'POST':
if request.POST.get('back'):
return redirect('home')
fields = ('oldpassword', 'newpassword1', 'newpassword2')
for fld in fields:
var[fld] = request.POST.get(fld, '')
if not user.check_password(var['oldpassword']):
var['error_message'] = 'Nesprávné heslo'
var['oldpassword'] = ''
elif var['newpassword1'] != var['newpassword2']:
var['error_message'] = 'Zadaná hesla se neshodují'
var['newpassword1'] = var['newpassword2'] = ''
elif len(var['newpassword1']) < MIN_PWLEN:
var['error_message'] = 'Nové heslo je příliš krátké'
var['newpassword1'] = var['newpassword2'] = ''
else:
user.set_password(var['newpassword1'])
user.save()
LOGGER.info(
'User "{}" ({:d}) changed password'.format(username, uid),
request)
return redirect('/accounts/pwchanged/')
return render(request, 'pwchange.xhtml', var)
def cron_update():
cron_getws2()
cron_gettr()
cron_proctr()
cron_deltr()
cron_delerr()
LOGGER.info('Batch processed')
def cron_update():
cron_getws2()
cron_gettr()
cron_proctr()
cron_deltr()
cron_delerr()
LOGGER.info('Batch processed')
def error(request):
LOGGER.debug('Internal server error page generated', request)
var = {'page_title': 'Interní chyba aplikace'}
return render(request,
'error.xhtml',
var,
status=HTTPStatus.INTERNAL_SERVER_ERROR)
def userinfo(request):
LOGGER.debug('User information page accessed', request)
return render(
request, 'user.xhtml', {
'page_title': 'Informace o uživateli',
'userinfo': getuserinfo(request.user),
})
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method), request, request.POST)
messages = []
if request.method == 'GET':
form = MainForm()
else:
form = MainForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
beg_date = cld['beg_date']
years = (cld['years'] if cld['years'] else 0)
months = (cld['months'] if cld['months'] else 0)
days = (cld['days'] if cld['days'] else 0)
messages.append(
('Trest skončí: {}'.format(calc(
beg_date,
years, months,
days)),
'res'))
messages.append(
('Třetina trestu: {}'.format(calc(
beg_date,
years // 3,
((years % 3) * 4) + (months // 3),
((months % 3) * 10) + (days // 3))),
'normal'))
messages.append(
('Polovina trestu: {}'.format(calc(
beg_date,
years // 2,
((years % 2) * 6) + (months // 2),
((months % 2) * 15) + (days // 2))),
'normal'))
messages.append(
('Dvě třetiny trestu: {}'.format(calc(
beg_date,
(years * 2) // 3,
(((years * 2) % 3) * 4) + ((months * 2) // 3),
(((months * 2) % 3) * 10) + ((days * 2) // 3))),
None))
else:
LOGGER.debug('Invalid form', request)
messages = [(INERR_SHORT, None)]
return render(
request,
'dvt_mainpage.xhtml',
{'app': APP,
'form': form,
'messages': messages,
'page_title': 'Doba výkonu trestu'})
def courts(request):
LOGGER.debug('List of courts accessed', request)
return render(
request,
'szr_courts.xhtml',
{'app': APP,
'page_title': 'Přehled soudů',
'rows': Court.objects.order_by('name').values('id', 'name')})
def userinfo(user):
from legal.common.utils import LOGGER
from legal.sur.models import Party
LOGGER.debug('Partial user information generated')
return (
(
'Počet sledovaných účastníků',
Party.objects.filter(uid=user).count()),
)
def cron_publishers():
def proc_publisher(tag, typ, high=False, subsidiary_region=False, subsidiary_county=False, reports=None):
pubid = int(tag['href'].rpartition('=')[2])
name = (
tag.text.replace(' ', ' ')
.replace('KS ', 'Krajský soud ')
.replace('MS ', 'Městský soud ')
.replace('OS Praha ', 'Obvodní soud Praha ')
.replace('OS ', 'Okresní soud ')
.replace('KSZ ', 'Krajské státní zastupitelství ')
.replace('MSZ ', 'Městské státní zastupitelství ')
.replace('OSZ Praha ', 'Obvodní státní zastupitelství Praha ')
.replace('OSZ ', 'Okresní státní zastupitelství ')
)
return Publisher.objects.update_or_create(
name=name,
defaults={
'type': typ,
'pubid': pubid,
'high': high,
'subsidiary_region': subsidiary_region,
'subsidiary_county': subsidiary_county,
'reports': reports,
'updated': datetime.now() - UPDATE_INTERVAL})[0]
def proc_publishers(soup, typ, high=False):
if high:
for tag in soup.find_all('a'):
proc_publisher(tag, typ, high=True)
else:
rep = proc_publisher(soup.select('dt a')[0], typ)
for tag in soup.find_all('dd'):
cls = tag.get('class', [])
subsidiary_region = 'pobockakraj' in cls
subsidiary_county = 'pobockaokres' in cls
proc_publisher(
tag.find('a'),
typ,
subsidiary_region=subsidiary_region,
subsidiary_county=subsidiary_county,
reports=rep)
for typ in TYPES:
try:
res = get(PUBLISHERS_URL.format(typ))
soup = BeautifulSoup(res.text, 'html.parser')
high = soup.find('div', 'bezlokality')
lower = soup.find('div', 'slokalitou')
proc_publishers(high, typ, high=True)
for reg in lower.find_all('dl'):
proc_publishers(reg, typ, high=False)
except:
pass
LOGGER.info('Publishers imported')
def stat():
from legal.cnb.models import FXrate, MPIrate, MPIstat
from legal.common.utils import LOGGER
LOGGER.debug('Partial statistics generated')
return (
('Počet kursových tabulek', FXrate.objects.count()),
('Počet historických úrokových sazeb', MPIrate.objects.count()),
('Počet aktuálních úrokových sazeb', MPIstat.objects.count()),
)
def userinfo(user):
from legal.common.utils import LOGGER
from legal.dir.models import Debtor
LOGGER.debug('Partial user information generated')
return (
(
'Počet sledovaných dlužníků',
Debtor.objects.filter(uid=user).count()),
)
def stat():
from legal.common.utils import LOGGER
from legal.common.models import Asset
LOGGER.debug('Partial statistics generated')
return (
(
'Počet položek v tabulce Asset',
Asset.objects.filter(assetid__startswith=HspConfig.name.upper()).count()),
)
def courts(request):
LOGGER.debug('List of courts accessed', request)
return render(
request, 'szr_courts.xhtml', {
'app': APP,
'page_title': 'Přehled soudů',
'rows': Court.objects.order_by('name').values('id', 'name')
})
def cron_gettr():
idx = Counter.objects.get(id='DL').number
while True:
soup = BeautifulSoup('', 'lxml')
soup.is_xml = True
envelope = soup.handle_starttag(
'Envelope', None,
'soapenv', {
'xmlns:soapenv': 'http://schemas.xmlsoap.org/soap/envelope/',
'xmlns:typ': 'http://isirpublicws.cca.cz/types/'})
header = soup.new_tag('Header', None, 'soapenv')
envelope.append(header)
body = soup.new_tag('Body', None, 'soapenv')
envelope.append(body)
req = soup.new_tag('getIsirWsPublicIdDataRequest', None, 'typ')
body.append(req)
idPodnetu = soup.new_tag('idPodnetu', None, None)
idPodnetu.append(str(idx))
req.append(idPodnetu)
url = 'https://isir.justice.cz:8443/isir_public_ws/IsirWsPublicService'
headers = {
'content-type': 'text/xml; charset=utf-8',
'SOAPAction': '"http://isirpublicws.cca.cz/types/"',
}
res = post(url, soup.renderContents(), headers=headers)
xml = res.content.decode('utf-8')
soup = BeautifulSoup(xml, 'lxml')
soup.is_xml = True
if not (soup.stav and soup.stav.string == 'OK' and soup.find('data')):
break
lst = []
for t_data in soup.find_all('data'):
idx = int(t_data.id.string)
lst.append(Transaction(
id=idx,
datumZalozeniUdalosti=convdt(t_data.datumzalozeniudalosti),
datumZverejneniUdalosti=convdt(t_data.datumzverejneniudalosti),
dokumentUrl=(t_data.dokumenturl.string.strip() if t_data.dokumenturl else None),
spisovaZnacka=t_data.spisovaznacka.string.strip(),
typUdalosti=t_data.typudalosti.string.strip(),
popisUdalosti=t_data.popisudalosti.string.strip(),
oddil=(t_data.oddil.string.strip() if t_data.oddil else None),
cisloVOddilu=(int(t_data.cislovoddilu.string) if t_data.cislovoddilu else None),
poznamkaText=(t_data.poznamka.string.strip() if t_data.poznamka else None),
error=False))
Transaction.objects.bulk_create(lst)
LOGGER.debug('Read {:d} transaction(s)'.format(len(lst)))
def cron_fixindex():
num = 0
for doc in Document.objects.all():
if not DocumentIndex.objects.using('sphinx').filter(id=doc.id).exists():
num += 1
update_index(doc)
if num:
LOGGER.info('Index fixed, {:d} record(s) added'.format(num))
else:
LOGGER.debug('Index fixed, no records added')
def courts(request):
LOGGER.debug('List of courts accessed', request)
rows = sorted([{'short': L2S[x], 'name': L2N[x]}
for x in Vec.objects.values_list('idOsobyPuvodce', flat=True).distinct()], key=lambda x: strxfrm(x['name']))
return render(
request,
'sir_courts.xhtml',
{'app': APP,
'page_title': 'Přehled insolvenčních soudů',
'rows': rows})
def userinfo(user):
from legal.common.utils import LOGGER
LOGGER.debug('Partial user information generated')
return (
('Uživatelské jméno', user.username),
('Jméno', user.first_name if user.first_name else ''),
('Příjmení', user.last_name if user.last_name else ''),
('E-mail', '<a href="mailto:{0}">{0}</a>'.format(user.email)
if user.email else ''),
('Datum založení účtu', '{:%d.%m.%Y}'.format(user.date_joined)),
)
def logout(request):
LOGGER.debug('Logout page accessed using method {}'.format(request.method),
request)
uid = request.user.id
username = request.user.username
auth.logout(request)
if username:
LOGGER.info('User "{}" ({:d}) logged out'.format(username, uid),
request)
return redirect('home')
def getuserinfo(user):
res = []
for idx in APPS:
conf = apps.get_app_config(idx)
if hasattr(conf, 'userinfo'):
res.extend(conf.userinfo(user))
LOGGER.debug(
'User information combined for user "{0.username}" ({0.id:d})'.format(
user))
return res
def cron_fixindex():
num = 0
for doc in Document.objects.all():
if not DocumentIndex.objects.using('sphinx').filter(
id=doc.id).exists():
num += 1
update_index(doc)
if num:
LOGGER.info('Index fixed, {:d} record(s) added'.format(num))
else:
LOGGER.debug('Index fixed, no records added')
def cron_remove_orphans():
num = 0
for doc in Document.objects.all():
if not File.objects.filter(document=doc).exists():
num += 1
DocumentIndex.objects.using('sphinx').filter(id=doc.id).delete()
doc.delete()
if num:
LOGGER.info('Removed {:d} orphan(s)'.format(num))
else:
LOGGER.debug('No orphans removed')
def cron_remove_orphans():
num = 0
for doc in Document.objects.all():
if not File.objects.filter(document=doc).exists():
num += 1
DocumentIndex.objects.using('sphinx').filter(id=doc.id).delete()
doc.delete()
if num:
LOGGER.info('Removed {:d} orphan(s)'.format(num))
else:
LOGGER.debug('No orphans removed')
def cron_notify():
for user in User.objects.all():
uid = user.id
text = szr_notice(uid) + sur_notice(uid) + sir_notice(
uid) + dir_notice(uid) + uds_notice(uid)
if text and user.email:
text += 'Server {} ({})\n'.format(LOCAL_SUBDOMAIN, LOCAL_URL)
send_mail('Zprava ze serveru {}'.format(LOCAL_SUBDOMAIN), text,
[user.email])
LOGGER.debug('Email sent to user "{}" ({:d})'.format(
User.objects.get(pk=uid).username, uid))
LOGGER.info('Emails sent')
def getappstat():
appstat = []
for app in APPS:
conf = apps.get_app_config(app)
if hasattr(conf, 'stat'):
appstat.append({
'abbr': conf.name.rpartition('.')[2],
'name': conf.verbose_name,
'stat': conf.stat(),
})
LOGGER.debug('Statistics combined')
return appstat
def htmllist(request):
LOGGER.debug('HTML list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
start = int(reqd['start']) if 'start' in reqd else 0
assert start >= 0
docins = DocumentIndex.objects.using('sphinx').filter(**par).order_by(
'-posted', 'id')
total = docins.count()
if total and start >= total:
start = total - 1
if start >= FTLIM:
if 'text' in reqd:
return render(
request, 'ftlim.xhtml', {
'app': APP,
'page_title': FTLIM_TITLE,
'limit': FTLIM,
'back': reverse('uds:mainpage')
})
docs = Document.objects.filter(**par).order_by('-posted',
'id').distinct()
total = docs.count()
if total and start >= total:
start = total - 1
docs = docs[start:(start + BATCH)]
else:
docins = list(docins[start:(start + BATCH)].values_list('id',
flat=True))
docs = Document.objects.filter(id__in=docins).order_by(
'-posted', 'id').distinct()
for doc in docs:
doc.files = File.objects.filter(
document=doc).order_by('fileid').distinct()
idx = 1
for file in doc.files:
file.brk = idx % 5 == 0
idx += 1
except:
raise Http404
return render(
request, 'uds_list.xhtml', {
'app': APP,
'page_title': 'Výsledky vyhledávání',
'rows': docs,
'pager': Pager(start, total, reverse('uds:htmllist'), reqd, BATCH),
'total': total,
'noindex': True
})
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method), request, request.POST)
today = date.today()
messages = []
if request.method == 'GET':
form = MainForm()
else:
form = MainForm(request.POST)
button = getbutton(request)
if button == 'set_beg_date':
form.data = form.data.copy()
form.data['beg_date'] = today
elif form.is_valid():
cld = form.cleaned_data
beg = cld['beg_date']
preset = cld['preset']
if preset == 'none':
dur = cld['dur']
unit = cld['unit']
else:
dur = int(preset[1:])
unit = preset[0]
per = Period(beg, dur, unit)
if per.error:
messages = [(per.msg, None)]
else:
if per.res != per.bus:
messages.append(('{} není pracovní den'.format(fdt(per.res)), None))
messages.append(('{} {}'.format(WD_NAMES[per.bus.weekday()], fdt(per.bus)), 'res'))
if per.unc:
messages.append(('(evidence pracovních dnů v tomto období není úplná)', 'note'))
else:
LOGGER.debug('Invalid form', request)
messages = [(INERR_SHORT, None)]
return render(request,
'lht_mainpage.xhtml',
{'app': APP,
'page_title': 'Konec lhůty',
'messages': messages,
'form': form})
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method),
request, request.POST)
err_message = ''
uid = request.user.id
page_title = 'Sledování účastníků řízení'
reqd = request.GET.copy()
start = int(reqd['start']) if 'start' in reqd else 0
if request.method == 'GET':
form = EmailForm(
initial=model_to_dict(get_object_or_404(User, pk=uid)))
else:
form = EmailForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
user = get_object_or_404(User, pk=uid)
user.email = cld['email']
user.save()
return redirect('sur:mainpage')
else:
LOGGER.debug('Invalid form', request)
err_message = INERR
res = Party.objects.filter(uid=uid).order_by('party', 'party_opt',
'pk').values()
total = res.count()
if start >= total and total:
start = total - 1
rows = res[start:start + BATCH]
for row in rows:
row['party_opt_text'] = TEXT_OPTS[row['party_opt']][1]
query = QueryDict(mutable=True)
query['party'] = row['party']
query['party_opt'] = TEXT_OPTS_KEYS[row['party_opt']]
row['search'] = query.urlencode()
query = QueryDict(mutable=True)
query['text'] = '"{}"'.format(row['party'])
row['uds_search'] = query.urlencode()
return render(
request, 'sur_mainpage.xhtml', {
'app': APP,
'form': form,
'page_title': page_title,
'err_message': err_message,
'rows': rows,
'pager': Pager(start, total, reverse('sur:mainpage'), reqd, BATCH),
'total': total
})
def sur_notice(uid):
text = ''
res = Found.objects.filter(uid=uid).order_by('name', 'id').distinct()
if res:
text = 'Byli nově zaznamenáni tito účastníci řízení, které sledujete:\n\n'
for item in res:
text += ' - {0.name}, {0.court}, sp. zn. {1}\n'.format(
item, composeref(item.senate, item.register, item.number, item.year))
text += ' {}\n\n'.format(item.url)
Found.objects.filter(uid=uid).delete()
LOGGER.info('Non-empty notice prepared for user "{}" ({:d})'.format(User.objects.get(pk=uid).username, uid))
Party.objects.filter(uid=uid).update(notify=False)
return text
def cron_refresh_links():
batch = Vec.objects.filter(datumVyskrtnuti__isnull=True, link__isnull=False, refreshed__isnull=True).order_by('id')
if not batch:
batch = Vec.objects.filter(datumVyskrtnuti__isnull=True, link__isnull=False).order_by('refreshed')
batch = batch[:REFRESH_BATCH]
num = 0
matrix = [0] * 5
for vec in batch:
matrix[refresh_link(vec)] += 1
num += 1
LOGGER.debug('Refreshed {:d} links(s), results: {}'.format(num, matrix))
def partyexport(request):
LOGGER.debug('Party export page accessed', request)
uid = request.user.id
uname = request.user.username
res = Party.objects.filter(uid=uid).order_by('party', 'party_opt', 'id').distinct()
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=sur.csv'
writer = csvwriter(response)
for item in res:
dat = (item.party + TEXT_OPTS_CA[item.party_opt],)
writer.writerow(dat)
LOGGER.info('User "{}" ({:d}) exported parties'.format(uname, uid), request)
return response
def courtinfo(request, court):
LOGGER.debug('Court information accessed, court="{}"'.format(court), request)
courtrooms = (
Hearing.objects.filter(courtroom__court_id=court).values('courtroom_id', 'courtroom__desc').distinct()
.order_by('courtroom__desc'))
judges = list(Hearing.objects.filter(courtroom__court_id=court).values('judge_id', 'judge__name').distinct())
judges.sort(key=stripjudge)
return render(
request,
'psj_court.xhtml',
{'courtrooms': courtrooms,
'judges': judges},
content_type='text/plain; charset=utf-8')
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method), request, request.POST)
err_message = ''
uid = request.user.id
page_title = 'Sledování nových dlužníků v insolvenci'
rdt = request.GET.copy()
start = int(rdt['start']) if 'start' in rdt else 0
if request.method == 'GET':
form = EmailForm(initial=model_to_dict(get_object_or_404(User, pk=uid)))
else:
form = EmailForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
user = get_object_or_404(User, pk=uid)
user.email = cld['email']
user.save()
return redirect('dir:mainpage')
else:
LOGGER.debug('Invalid form', request)
err_message = INERR
debtors = Debtor.objects.filter(uid=uid).order_by('desc', 'pk').values()
total = debtors.count()
if start >= total and total:
start = total - 1
rows = debtors[start:(start + BATCH)]
for row in rows:
query = QueryDict(mutable=True)
query['role_debtor'] = query['deleted'] = 'on'
for key in ('court', 'genid', 'taxid', 'birthid', 'date_birth', 'year_birth_from', 'year_birth_to'):
if row[key]:
query[key] = row[key]
for key in OFIELDS:
if row[key]:
query[key] = row[key]
key_opt = '{}_opt'.format(key)
query[key_opt] = TEXT_OPTS_KEYS[row[key_opt]]
row['search'] = query.urlencode()
return render(
request,
'dir_mainpage.xhtml',
{'app': APP,
'form': form,
'page_title': page_title,
'err_message': err_message,
'rows': rows,
'pager': Pager(start, total, reverse('dir:mainpage'), rdt, BATCH),
'total': total})
def csvlist(request):
LOGGER.debug('CSV list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
res = Hearing.objects.filter(**par).order_by('time', 'pk').distinct()
except:
raise Http404
total = res.count()
if total > EXLIM:
return render(
request,
'exlim.xhtml',
{'app': APP,
'page_title': EXLIM_TITLE,
'limit': EXLIM,
'total': total,
'back': reverse('psj:mainpage')})
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Jednani.csv'
writer = csvwriter(response)
hdr = (
'Soud',
'Jednací síň',
'Datum',
'Čas',
'Spisová značka',
'Řešitel',
'Účastníci řízení',
'Druh jednání',
'Neveřejné',
'Zrušeno',
)
writer.writerow(hdr)
for item in res:
dat = (
item.courtroom.court.name,
item.courtroom.desc,
'{:%d.%m.%Y}'.format(item.time),
'{:%H:%M}'.format(item.time),
composeref(item.senate, item.register, item.number, item.year),
item.judge.name,
';'.join([p['name'] for p in item.parties.values()]),
item.form.name,
'ano' if item.closed else 'ne',
'ano' if item.cancelled else 'ne',
)
writer.writerow(dat)
return response
def csvlist(request):
LOGGER.debug('CSV list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
resins = DocumentIndex.objects.using('sphinx').filter(**par).order_by(
'posted', 'id')
except:
raise Http404
total = resins.count()
if total > EXLIM:
return render(
request, 'exlim.xhtml', {
'app': APP,
'page_title': EXLIM_TITLE,
'limit': EXLIM,
'total': total,
'back': reverse('uds:mainpage')
})
resins = list(resins.values_list('id', flat=True))
res = Document.objects.filter(id__in=resins).order_by('posted',
'id').distinct()
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Dokumenty.csv'
writer = csvwriter(response)
hdr = (
'Datum vyvěšení',
'Soud/státní zastupitelství',
'Popis dokumentu',
'Spisová značka/číslo jednací',
'Agenda',
'Soubory',
)
writer.writerow(hdr)
for item in res:
files = File.objects.filter(
document=item).order_by('fileid').distinct()
dat = (
'{:%d.%m.%Y}'.format(item.posted),
item.publisher.name,
item.desc,
item.ref,
item.agenda.desc,
';'.join([
join(REPO_PREFIX, str(fil.fileid), fil.name) for fil in files
]),
)
writer.writerow(dat)
return response
def stat():
from legal.common.utils import LOGGER
from legal.psj.models import Courtroom, Party, Judge, Form, Hearing, Task
now = datetime.now()
LOGGER.debug('Partial statistics generated')
return (
(
'Počet jednacích síní',
Courtroom.objects.count()),
(
'Počet řešitelů',
Judge.objects.count()),
(
'Počet druhů jednání',
Form.objects.count()),
(
'Počet účastníků',
Party.objects.count()),
(
'Počet nových účastníků za posledních 24 hodin',
Party.objects.filter(timestamp_add__gte=(now - timedelta(hours=24))).count()),
(
'Počet nových účastníků za poslední týden',
Party.objects.filter(timestamp_add__gte=(now - timedelta(weeks=1))).count()),
(
'Počet nových účastníků za poslední měsíc',
Party.objects.filter(timestamp_add__gte=(now - timedelta(days=30))).count()),
(
'Počet jednání',
Hearing.objects.count()),
(
'Počet nových jednání za posledních 24 hodin',
Hearing.objects.filter(timestamp_add__gte=(now - timedelta(hours=24))).count()),
(
'Počet nových jednání za poslední týden',
Hearing.objects.filter(timestamp_add__gte=(now - timedelta(weeks=1))).count()),
(
'Počet nových jednání za poslední měsíc',
Hearing.objects.filter(timestamp_add__gte=(now - timedelta(days=30))).count()),
(
'Počet položek v tabulce Task',
Task.objects.count()),
(
'Počet položek v tabulce Task starších než 12 hodin',
Task.objects.filter(timestamp_add__lt=(now - timedelta(hours=12))).count()),
(
'Počet položek v tabulce Task starších než 24 hodin',
Task.objects.filter(timestamp_add__lt=(now - timedelta(hours=24))).count()),
)
def stat():
from legal.common.utils import LOGGER
from legal.udn.models import Agenda, Party, Decision
now = datetime.now()
LOGGER.debug('Partial statistics generated')
return (
(
'Počet oblastí',
Agenda.objects.count()),
(
'Počet účastníků řízení',
Party.objects.count()),
(
'Počet nových účastníků řízení za posledních 24 hodin',
Party.objects.filter(timestamp_add__gte=(now - timedelta(hours=24))).count()),
(
'Počet nových účastníků řízení za poslední týden',
Party.objects.filter(timestamp_add__gte=(now - timedelta(weeks=1))).count()),
(
'Počet nových účastníků řízení za poslední měsíc',
Party.objects.filter(timestamp_add__gte=(now - timedelta(days=30))).count()),
(
'Počet rozhodnutí',
Decision.objects.count()),
(
'Počet nových rozhodnutí za posledních 24 hodin',
Decision.objects.filter(timestamp_add__gte=(now - timedelta(hours=24))).count()),
(
'Počet nových rozhodnutí za poslední týden',
Decision.objects.filter(timestamp_add__gte=(now - timedelta(weeks=1))).count()),
(
'Počet nových rozhodnutí za poslední měsíc',
Decision.objects.filter(timestamp_add__gte=(now - timedelta(days=30))).count()),
(
'Počet neúplných rozhodnutí',
Decision.objects.filter(anonfilename='').count()),
(
'Počet neúplných rozhodnutí starších než 30 dnů',
Decision.objects.filter(anonfilename='', date__lt=(now - timedelta(days=30))).count()),
(
'Počet neúplných rozhodnutí starších než 60 dnů',
Decision.objects.filter(anonfilename='', date__lt=(now - timedelta(days=60))).count()),
(
'Počet neúplných rozhodnutí starších než 90 dnů',
Decision.objects.filter(anonfilename='', date__lt=(now - timedelta(days=90))).count()),
(
'Počet neúplných rozhodnutí starších než 1 rok',
Decision.objects.filter(anonfilename='', date__lt=(now - timedelta(days=365))).count()),
)
def stat():
from legal.cnb.models import FXrate, MPIrate, MPIstat
from legal.common.utils import LOGGER
LOGGER.debug('Partial statistics generated')
return (
(
'Počet kursových tabulek',
FXrate.objects.count()),
(
'Počet historických úrokových sazeb',
MPIrate.objects.count()),
(
'Počet aktuálních úrokových sazeb',
MPIstat.objects.count()),
)
def userinfo(user):
from legal.common.utils import LOGGER
from legal.knr.models import Place, Car, Formula
LOGGER.debug('Partial user information generated')
return (
(
'Počet míst',
Place.objects.filter(uid=user).count()),
(
'Počet vozidel',
Car.objects.filter(uid=user).count()),
(
'Počet předpisů',
Formula.objects.filter(uid=user).count()),
)
def cron_notify():
for user in User.objects.all():
uid = user.id
text = szr_notice(uid) + sur_notice(uid) + sir_notice(uid) + dir_notice(uid) + uds_notice(uid)
if text and user.email:
text += 'Server {} ({})\n'.format(LOCAL_SUBDOMAIN, LOCAL_URL)
send_mail(
'Zprava ze serveru {}'.format(LOCAL_SUBDOMAIN),
text,
[user.email])
LOGGER.debug(
'Email sent to user "{}" ({:d})'
.format(User.objects.get(pk=uid).username, uid))
LOGGER.info('Emails sent')
def cron_schedule(*args):
dates = []
for arg in args:
if len(arg) > 2:
string = arg.split('.')
dates.append(date(*map(int, string[2::-1])))
else:
dates.append(date.today() + timedelta(int(arg)))
for court in Court.objects.all():
if court.id in {SUPREME_COURT, SUPREME_ADMINISTRATIVE_COURT}:
continue
for dat in dates:
Task.objects.get_or_create(court=court, date=dat)
LOGGER.info('Tasks scheduled')
def partydelall(request):
LOGGER.debug('Delete all parties page accessed using method {}'.format(request.method), request)
uid = request.user.id
uname = request.user.username
if request.method == 'GET':
return render(
request,
'sur_partydelall.xhtml',
{'app': APP,
'page_title': 'Smazání všech účastníků'})
else:
if getbutton(request) == 'yes' and 'conf' in request.POST and request.POST['conf'] == 'Ano':
Party.objects.filter(uid=uid).delete()
LOGGER.info('User "{}" ({:d}) deleted all parties'.format(uname, uid), request)
return redirect('sur:mainpage')
def sir_notice(uid):
text = ''
res = Tracked.objects.filter(uid=uid, vec__link__isnull=False).order_by('desc', 'id').distinct()
if res:
text = 'Došlo ke změně v těchto insolvenčních řízeních, která sledujete:\n\n'
for ins in res:
refresh_link(ins.vec)
text += (
' - {0}sp. zn. {1} {2.senat:d} INS {2.bc:d}/{2.rocnik:d}\n'
.format('{}, '.format(ins.desc) if ins.desc else '', L2S[ins.vec.idOsobyPuvodce], ins.vec))
text += ' {}\n\n'.format(ins.vec.link)
Tracked.objects.filter(uid=uid, vec__link__isnull=False).delete()
LOGGER.info('Non-empty notice prepared for user "{}" ({:d})'.format(User.objects.get(pk=uid).username, uid))
Insolvency.objects.filter(uid=uid).update(notify=False)
return text
def cron_courtrooms():
for court in Court.objects.exclude(id=SUPREME_ADMINISTRATIVE_COURT):
try:
sleep(1)
res = get(LIST_COURTROOMS.format(court.pk))
soup = BeautifulSoup(res.text, 'xml')
for room in soup.find_all('jednaciSin'):
croom, croomc = Courtroom.objects.get_or_create(
court=court,
desc=room.nazev.string)
if not croomc:
croom.save()
except: # pragma: no cover
LOGGER.warning('Error downloading courtrooms')
LOGGER.info('Courtrooms downloaded')
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method), request, request.POST)
err_message = ''
uid = request.user.id
page_title = 'Sledování účastníků řízení'
reqd = request.GET.copy()
start = int(reqd['start']) if 'start' in reqd else 0
if request.method == 'GET':
form = EmailForm(initial=model_to_dict(get_object_or_404(User, pk=uid)))
else:
form = EmailForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
user = get_object_or_404(User, pk=uid)
user.email = cld['email']
user.save()
return redirect('sur:mainpage')
else:
LOGGER.debug('Invalid form', request)
err_message = INERR
res = Party.objects.filter(uid=uid).order_by('party', 'party_opt', 'pk').values()
total = res.count()
if start >= total and total:
start = total - 1
rows = res[start:start + BATCH]
for row in rows:
row['party_opt_text'] = TEXT_OPTS[row['party_opt']][1]
query = QueryDict(mutable=True)
query['party'] = row['party']
query['party_opt'] = TEXT_OPTS_KEYS[row['party_opt']]
row['search'] = query.urlencode()
query = QueryDict(mutable=True)
query['text'] = '"{}"'.format(row['party'])
row['uds_search'] = query.urlencode()
return render(
request,
'sur_mainpage.xhtml',
{'app': APP,
'form': form,
'page_title': page_title,
'err_message': err_message,
'rows': rows,
'pager': Pager(start, total, reverse('sur:mainpage'), reqd, BATCH),
'total': total})
def htmllist(request):
LOGGER.debug('HTML list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
start = int(reqd['start']) if 'start' in reqd else 0
assert start >= 0
res = Vec.objects.filter(**par).order_by('firstAction', 'rocnik', 'bc', 'idOsobyPuvodce').distinct()
except:
raise Http404
total = res.count()
if total and start >= total:
start = total - 1
creditors = 'creditors' in reqd
batch = 10 if creditors else 20
rows = res[start:start + batch]
for row in rows:
row.court = L2N[row.idOsobyPuvodce]
row.court_short = L2S[row.idOsobyPuvodce]
row.court_reg = L2R[row.idOsobyPuvodce]
row.state = S2D[row.druhStavRizeni.desc] if row.druhStavRizeni else '(není známo)'
row.debtors = []
for osoba in getosoby(row, 'debtor'):
row.debtors.append({
'text': o2s(osoba, detailed=True),
'id': osoba.id})
row.trustees = []
for osoba in getosoby(row, 'trustee'):
row.trustees.append({
'text': o2s(osoba),
'id': osoba.id})
if creditors:
row.creditors = []
for osoba in getosoby(row, 'motioner', 'creditor'):
row.creditors.append({'text': o2s(osoba), 'id': osoba.id})
return render(
request,
'pir_list.xhtml',
{'app': APP,
'page_title': 'Výsledky vyhledávání',
'rows': rows,
'creditors': creditors,
'pager': Pager(start, total, reverse('pir:htmllist'), reqd, batch),
'total': total,
'NULL_REGISTERS': NULL_REGISTERS,
'noindex': True})
