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 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 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 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 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 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.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 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 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 procform(request, idx=0):
LOGGER.debug('Proceedings form accessed using method {}, id={}'.format(request.method, idx), request, request.POST)
err_message = ''
uid = request.user.id
uname = request.user.username
page_title = 'Úprava řízení' if idx else 'Nové řízení'
button = getbutton(request)
if request.method == 'GET':
form = ProcForm(initial=model_to_dict(get_object_or_404(Proceedings, pk=idx, uid=uid))) if idx else ProcForm()
elif button == 'back':
return redirect('szr:mainpage')
else:
form = ProcForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
if not cld['senate']:
cld['senate'] = 0
if idx:
proc = get_object_or_404(Proceedings, pk=idx, uid=uid)
cld['pk'] = idx
cld['timestamp_add'] = proc.timestamp_add
cld['court_id'] = cld['court']
del cld['court']
onlydesc = (
idx and proc.court.id == cld['court_id'] and proc.senate == cld['senate']
and proc.register == cld['register'] and proc.number == cld['number'] and proc.year == cld['year'])
if onlydesc:
cld['changed'] = proc.changed
cld['updated'] = proc.updated
cld['hash'] = proc.hash
cld['auxid'] = proc.auxid
cld['notify'] = proc.notify
proc = Proceedings(uid_id=uid, **cld)
if not onlydesc:
updateproc(proc)
proc.save()
LOGGER.info(
'User "{}" ({:d}) {} proceedings "{}" ({})'
.format(uname, uid, 'updated' if idx else 'added', proc.desc, p2s(proc)),
request)
return redirect('szr:mainpage')
else: # pragma: no cover
LOGGER.debug('Invalid form', request)
err_message = INERR
return render(
request,
'szr_procform.xhtml',
{'app': APP,
'form': form,
'page_title': page_title,
'err_message': err_message})
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 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 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.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 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 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 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 stat():
from legal.common.utils import LOGGER
from legal.uds.models import Publisher, Agenda, Document, File, Retrieved
now = datetime.now()
LOGGER.debug('Partial statistics generated')
return (
('Počet soudů a státních zastupitelství',
Publisher.objects.count()),
('Z toho soudů', Publisher.objects.filter(type='SOUD').count()),
('Z toho státních zastupitelství',
Publisher.objects.filter(type='ZAST').count()),
('Z toho nejvyšších a vrchních',
Publisher.objects.filter(high=True).count()),
('Z toho krajských',
Publisher.objects.filter(high=False,
reports__isnull=True).count()),
('Z toho okresních',
Publisher.objects.filter(reports__isnull=False).count()),
('Z toho krajských poboček',
Publisher.objects.filter(subsidiary_region=True).count()),
('Z toho okresních poboček',
Publisher.objects.filter(subsidiary_county=True).count()),
('Počet agend', Agenda.objects.count()),
('Počet dokumentů', Document.objects.count()),
('Počet dokumentů přidaných za posledních 24 hodin',
Document.objects.filter(
timestamp_add__gte=(now - timedelta(hours=24))).count()),
('Počet dokumentů přidaných za poslední týden',
Document.objects.filter(
timestamp_add__gte=(now - timedelta(weeks=1))).count()),
('Počet dokumentů přidaných za poslední měsíc',
Document.objects.filter(
timestamp_add__gte=(now - timedelta(days=30))).count()),
('Počet souborů', File.objects.count()),
('Počet souborů přidaných za posledních 24 hodin',
File.objects.filter(
document__timestamp_add__gte=(now -
timedelta(hours=24))).count()),
('Počet souborů přidaných za poslední týden',
File.objects.filter(
document__timestamp_add__gte=(now -
timedelta(weeks=1))).count()),
('Počet souborů přidaných za poslední měsíc',
File.objects.filter(
document__timestamp_add__gte=(now -
timedelta(days=30))).count()),
('Počet osob pro příští notifikaci', Retrieved.objects.count()),
)
def lostpw(request):
LOGGER.debug(
'Lost password page accessed using method {}'.format(request.method),
request, request.POST)
err_message = None
page_title = 'Ztracené heslo'
if request.method == 'GET':
form = LostPwForm()
elif request.POST.get('back'):
return redirect('login')
else:
form = LostPwForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
users = User.objects.filter(username=cld['username'])
if users.exists() and users[0].email:
user = users[0]
link = '{:032x}'.format(getrandbits(16 * 8))
PwResetLink(user_id=user.id, link=link).save()
text = '''Vážený uživateli,
někdo požádal o obnovení hesla pro Váš účet "{0}" na serveru {1} ({2}).
Pokud skutečně chcete své heslo obnovit, použijte, prosím, následující jednorázový odkaz:
{2}{3}
V případě, že jste o obnovení hesla nežádali, můžete tuto zprávu ignorovat.
Server {1} ({2})
'''.format(user.username, LOCAL_SUBDOMAIN, LOCAL_URL,
reverse('resetpw', args=(link, )))
send_mail('Link pro obnoveni hesla', text, (user.email, ))
LOGGER.info(
'Password recovery link for user "{0.username}" ({0.id:d}) sent'
.format(user), request)
return redirect('/accounts/pwlinksent/')
else:
LOGGER.debug('Invalid form', request)
err_message = 'Prosím, opravte označená pole ve formuláři'
return render(request, 'lostpw.xhtml', {
'form': form,
'page_title': page_title,
'err_message': err_message,
})
def jsonlist(request):
LOGGER.debug('JSON 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='application/json; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Dokumenty.json'
lst = []
for item in res:
files = File.objects.filter(
document=item).order_by('fileid').distinct()
lst.append({
'posted':
item.posted.isoformat(),
'publisher':
item.publisher.name,
'desc':
item.desc,
'ref':
item.ref,
'agenda':
item.agenda.desc,
'files': [{
'id': f.fileid,
'name': f.name,
'url': join(REPO_PREFIX, str(f.fileid), f.name)
} for f in files],
})
dump(lst, response)
return response
def procexport(request):
LOGGER.debug('Proceedings export page accessed', request)
uid = request.user.id
uname = request.user.username
res = Proceedings.objects.filter(uid=uid).order_by('desc', 'pk').distinct()
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=szr.csv'
writer = csvwriter(response)
for proc in res:
dat = (proc.desc, proc.court.id,
composeref(proc.senate, proc.register, proc.number, proc.year))
writer.writerow(dat)
LOGGER.info('User "{}" ({:d}) exported proceedings'.format(uname, uid),
request)
return response
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 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 debtordelall(request):
LOGGER.debug('Delete all debtors page accessed using method {}'.format(request.method), request)
uid = request.user.id
uname = request.user.username
if request.method == 'GET':
return render(
request,
'dir_debtordelall.xhtml',
{'app': APP,
'page_title': 'Smazání všech dlužníků'})
else:
if getbutton(request) == 'yes' and 'conf' in request.POST and request.POST['conf'] == 'Ano':
Debtor.objects.filter(uid=uid).delete()
LOGGER.info('User "{}" ({:d}) deleted all debtors'.format(uname, uid), request)
return redirect('dir:mainpage')
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})
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 jsonlist(request):
LOGGER.debug('JSON list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
res = Decision.objects.filter(**par).order_by('date', '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('udn:mainpage')})
response = HttpResponse(content_type='application/json; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Rozhodnuti.json'
lst = []
court = {
'id': SUPREME_ADMINISTRATIVE_COURT,
'name': SUPREME_ADMINISTRATIVE_COURT_NAME,
}
for item in res:
files = {'abridged': join(REPO_PREFIX, item.filename)}
if item.anonfilename:
files['anonymized'] = join(REPO_PREFIX, item.anonfilename)
lst.append({
'court': court,
'date': item.date.isoformat(),
'ref': {
'senate': item.senate,
'register': item.register,
'number': item.number,
'year': item.year,
'page': item.page,
},
'agenda': item.agenda.desc,
'parties': [p['name'] for p in item.parties.values()],
'files': files,
})
dump(lst, response)
return response
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method),
request, request.POST)
err_message = ''
page_title = apps.get_app_config(APP).verbose_name
if request.method == 'GET':
form = MainForm()
return render(
request, 'pir_mainpage.xhtml', {
'app': APP,
'page_title': page_title,
'err_message': err_message,
'form': form
})
form = MainForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
for key in ('name', 'first_name', 'city'):
if not cld[key]:
del cld[key + '_opt']
cld['birthid'] = cld['birthid'].replace('/', '')
query = QueryDict(mutable=True)
for key in cld:
if cld[key]:
query[key] = cld[key]
for key in ('role_debtor', 'role_trustee', 'role_creditor', 'deleted',
'creditors'):
if cld[key]:
query[key] = 'on'
query['start'] = 0
del query['format']
return redirect('{}?{}'.format(
reverse('{}:{}list'.format(APP, cld['format'])),
query.urlencode()))
LOGGER.debug('Invalid form', request)
err_message = INERR
return render(
request, 'pir_mainpage.xhtml', {
'app': APP,
'page_title': page_title,
'err_message': err_message,
'form': form
})
def partyform(request, idx=0):
LOGGER.debug('Party form accessed using method {}, id={}'.format(request.method, idx), request, request.POST)
err_message = ''
uid = request.user.id
uname = request.user.username
page_title = 'Úprava účastníka' if idx else 'Nový účastník'
button = getbutton(request)
if request.method == 'GET':
if idx:
dct = model_to_dict(get_object_or_404(Party, pk=idx, uid=uid))
dct['party_opt'] = TEXT_OPTS_KEYS[dct['party_opt']]
form = PartyForm(initial=dct)
else:
form = PartyForm()
elif button == 'back':
return redirect('sur:mainpage')
else:
form = PartyForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
if idx:
res = get_object_or_404(Party, pk=idx, uid=uid)
cld['pk'] = idx
cld['notify'] = res.notify
cld['timestamp_add'] = res.timestamp_add
res = Party(uid_id=uid, **cld)
res.party_opt = TEXT_OPTS_KEYS.index(cld['party_opt'])
res.save()
LOGGER.info(
'User "{}" ({:d}) {} party {}'.format(uname, uid, 'updated' if idx else 'added', res.party),
request)
return redirect('sur:mainpage')
else:
LOGGER.debug('Invalid form', request)
err_message = INERR
return render(
request,
'sur_partyform.xhtml',
{'app': APP,
'form': form,
'min_chars': grammar(MIN_LENGTH, GR_CHAR),
'page_title': page_title,
'err_message': err_message})
def jsonlist(request):
LOGGER.debug('JSON 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='application/json; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Jednani.json'
lst = []
for item in res:
court = {
'id': item.courtroom.court.id,
'name': item.courtroom.court.name,
}
lst.append({
'court': court,
'courtroom': item.courtroom.desc,
'time': item.time.isoformat(),
'ref': {
'senate': item.senate,
'register': item.register,
'number': item.number,
'year': item.year,
},
'judge': item.judge.name,
'parties': [p['name'] for p in item.parties.values()],
'form': item.form.name,
'closed': item.closed,
'cancelled': item.cancelled,
})
dump(lst, response)
return response
def cron_getws2():
idx = Counter.objects.get(id='PR').number
for vec in Vec.objects.filter(id__gt=idx, link__isnull=True).order_by('id'):
subsoup = get_ws2(vec)
if (subsoup.pocetVysledku and subsoup.cisloSenatu and subsoup.urlDetailRizeni
and (subsoup.nazevOrganizace.string.strip()[:PREF] == L2N[vec.idOsobyPuvodce][:PREF])):
Vec.objects.filter(id=vec.id).update(
senat=int(subsoup.cisloSenatu.string),
link=subsoup.urlDetailRizeni.string.strip())
idx = vec.id
Counter.objects.update_or_create(id='PR', defaults={'number': idx})
LOGGER.debug('WS2 information added')
def csvlist(request):
LOGGER.debug('CSV list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
res = Decision.objects.filter(**par).order_by('date', '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('udn:mainpage')})
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Rozhodnuti.csv'
writer = csvwriter(response)
hdr = (
'Soud',
'Datum',
'Číslo jednací',
'Oblast',
'Účastníci řízení',
'Zkrácené znění',
'Anonymisované znění',
)
writer.writerow(hdr)
for item in res:
dat = (
SUPREME_ADMINISTRATIVE_COURT_NAME,
'{:%d.%m.%Y}'.format(item.date),
composeref(item.senate, item.register, item.number, item.year, item.page),
item.agenda.desc,
';'.join([par['name'] for par in item.parties.values()]),
join(REPO_PREFIX, item.filename),
join(REPO_PREFIX, item.anonfilename) if item.anonfilename else '',
)
writer.writerow(dat)
return response
def jsonlist(request):
LOGGER.debug('JSON list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
res = Vec.objects.filter(**par).order_by('firstAction', 'rocnik', 'bc',
'idOsobyPuvodce').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('pir:mainpage')
})
response = HttpResponse(content_type='application/json; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Insolvence.json'
lst = []
for item in res:
par = {
'court': L2N[item.idOsobyPuvodce],
'ref': {
'court': L2S[item.idOsobyPuvodce],
'senate': item.senat,
'register': 'INS',
'number': item.bc,
'year': item.rocnik,
},
'state':
S2D[item.druhStavRizeni.desc] if item.druhStavRizeni else '',
'debtors': json_addparties(getosoby(item, 'debtor')),
'trustees': json_addparties(getosoby(item, 'trustee')),
}
if 'creditors' in reqd:
par['creditors'] = json_addparties(
getosoby(item, 'motioner', 'creditor'))
lst.append(par)
dump(lst, response)
return response
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method), request, request.POST)
err_message = ''
page_title = apps.get_app_config(APP).verbose_name
if request.method == 'GET':
form = MainForm()
return render(
request,
'pir_mainpage.xhtml',
{'app': APP,
'page_title': page_title,
'err_message': err_message,
'form': form})
form = MainForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
for key in ('name', 'first_name', 'city'):
if not cld[key]:
del cld[key + '_opt']
cld['birthid'] = cld['birthid'].replace('/', '')
query = QueryDict(mutable=True)
for key in cld:
if cld[key]:
query[key] = cld[key]
for key in ('role_debtor', 'role_trustee', 'role_creditor', 'deleted', 'creditors'):
if cld[key]:
query[key] = 'on'
query['start'] = 0
del query['format']
return redirect('{}?{}'.format(
reverse('{}:{}list'.format(APP, cld['format'])),
query.urlencode()))
LOGGER.debug('Invalid form', request)
err_message = INERR
return render(
request,
'pir_mainpage.xhtml',
{'app': APP,
'page_title': page_title,
'err_message': err_message,
'form': form})
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 insexport(request):
LOGGER.debug('Proceedings export page accessed', request)
uid = request.user.id
uname = request.user.username
res = Insolvency.objects.filter(uid=uid).order_by('desc', 'pk').distinct()
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=sir.csv'
writer = csvwriter(response)
for idx in res:
dat = (
idx.desc,
str(idx.number),
str(idx.year),
'ano' if idx.detailed else 'ne',
)
writer.writerow(dat)
LOGGER.info('User "{}" ({:d}) exported proceedings'.format(uname, uid), request)
return response
def insform(request, idx=0):
LOGGER.debug(
'Proceedings form accessed using method {}, id={}'.format(
request.method, idx), request, request.POST)
err_message = ''
uid = request.user.id
uname = request.user.username
page_title = 'Úprava řízení' if idx else 'Nové řízení'
button = getbutton(request)
if request.method == 'GET':
form = InsForm(initial=model_to_dict(
get_object_or_404(Insolvency, pk=idx,
uid=uid))) if idx else InsForm()
elif button == 'back':
return redirect('sir:mainpage')
else:
form = InsForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
if idx:
res = get_object_or_404(Insolvency, pk=idx, uid=uid)
cld['pk'] = idx
cld['notify'] = res.notify
cld['timestamp_add'] = res.timestamp_add
res = Insolvency(uid_id=uid, **cld)
res.save()
LOGGER.info(
'User "{}" ({:d}) {} proceedings "{}" ({})'.format(
uname, uid, 'updated' if idx else 'added', res.desc,
p2s(res)), request)
return redirect('sir:mainpage')
else:
LOGGER.debug('Invalid form', request)
err_message = INERR
return render(
request, 'sir_insform.xhtml', {
'app': APP,
'form': form,
'page_title': page_title,
'err_message': err_message
})
def jsonlist(request):
LOGGER.debug('JSON list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
res = Vec.objects.filter(**par).order_by('firstAction', 'rocnik', 'bc', 'idOsobyPuvodce').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('pir:mainpage')})
response = HttpResponse(content_type='application/json; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Insolvence.json'
lst = []
for item in res:
par = {
'court': L2N[item.idOsobyPuvodce],
'ref': {
'court': L2S[item.idOsobyPuvodce],
'senate': item.senat,
'register': 'INS',
'number': item.bc,
'year': item.rocnik,
},
'state': S2D[item.druhStavRizeni.desc]
if item.druhStavRizeni else '',
'debtors': json_addparties(getosoby(item, 'debtor')),
'trustees': json_addparties(getosoby(item, 'trustee')),
}
if 'creditors' in reqd:
par['creditors'] = json_addparties(getosoby(item, 'motioner', 'creditor'))
lst.append(par)
dump(lst, response)
return response
def resetpw(request, link):
LOGGER.debug('Password reset page accessed', request)
PwResetLink.objects.filter(timestamp_add__lt=(datetime.now() -
LINKLIFE)).delete()
link = get_object_or_404(PwResetLink, link=link)
user = link.user
newpassword = ''
for _ in range(PWLEN):
newpassword += choice(PWCHARS)
user.set_password(newpassword)
user.save()
link.delete()
LOGGER.info(
'Password for user "{}" ({:d}) reset'.format(user.username, user.id),
request)
return render(request, 'pwreset.xhtml', {
'page_title': 'Heslo bylo obnoveno',
'newpassword': newpassword,
})
def insexport(request):
LOGGER.debug('Proceedings export page accessed', request)
uid = request.user.id
uname = request.user.username
res = Insolvency.objects.filter(uid=uid).order_by('desc', 'pk').distinct()
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=sir.csv'
writer = csvwriter(response)
for idx in res:
dat = (
idx.desc,
str(idx.number),
str(idx.year),
'ano' if idx.detailed else 'ne',
)
writer.writerow(dat)
LOGGER.info('User "{}" ({:d}) exported proceedings'.format(uname, uid),
request)
return response
def csvlist(request):
LOGGER.debug('CSV list accessed', request, request.GET)
reqd = request.GET.copy()
try:
par = g2p(reqd)
res = Vec.objects.filter(**par).order_by('firstAction', 'rocnik', 'bc',
'idOsobyPuvodce').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('pir:mainpage')
})
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment; filename=Insolvence.csv'
writer = csvwriter(response)
hdr = (
'Soud',
'Spisová značka',
'Stav řízení',
)
writer.writerow(hdr)
for item in res:
dat = (
L2N[item.idOsobyPuvodce],
'{}{} INS {:d}/{:d}'.format(
L2S[item.idOsobyPuvodce],
' {:d}'.format(item.senat) if item.senat else '', item.bc,
item.rocnik),
(S2D[item.druhStavRizeni.desc]
if item.druhStavRizeni else '(není známo)'),
)
writer.writerow(dat)
return response
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method), request, request.POST)
err_message = ''
page_title = apps.get_app_config(APP).verbose_name
if request.method == 'GET':
form = MainForm()
return render(
request,
'psj_mainpage.xhtml',
{'app': APP,
'page_title': page_title,
'err_message': err_message,
'form': form})
else:
form = MainForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
if not cld['party']:
del cld['party_opt']
query = QueryDict(mutable=True)
for key in cld:
if cld[key]:
query[key] = cld[key]
query['start'] = 0
del query['format']
return redirect('{}?{}'.format(
reverse('{}:{}list'.format(APP, cld['format'])),
query.urlencode()))
else:
LOGGER.debug('Invalid form', request)
err_message = INERR
return render(
request,
'psj_mainpage.xhtml',
{'app': APP,
'page_title': page_title,
'err_message': err_message,
'form': form})
def mainpage(request):
LOGGER.debug('Main page accessed using method {}'.format(request.method),
request, request.POST)
err_message = ''
page_title = apps.get_app_config(APP).verbose_name
agendas = Agenda.objects.all().order_by('desc')
if request.method == 'GET':
form = MainForm()
return render(
request, 'uds_mainpage.xhtml', {
'app': APP,
'page_title': page_title,
'err_message': err_message,
'agendas': agendas,
'form': form
})
form = MainForm(request.POST)
if form.is_valid():
cld = form.cleaned_data
query = QueryDict(mutable=True)
for key in cld:
if cld[key]:
query[key] = cld[key]
query['start'] = 0
del query['format']
return redirect('{}?{}'.format(
reverse('{}:{}list'.format(APP, cld['format'])),
query.urlencode()))
err_message = INERR
LOGGER.debug('Invalid form', request)
return render(
request, 'uds_mainpage.xhtml', {
'app': APP,
'page_title': page_title,
'err_message': err_message,
'agendas': agendas,
'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í změn v ří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('szr:mainpage')
else:
LOGGER.debug('Invalid form', request)
err_message = INERR
proc = Proceedings.objects.filter(uid=uid).order_by('desc', 'pk')
total = proc.count()
if start >= total and total:
start = total - 1
rows = proc[start:start + BATCH]
return render(
request, 'szr_mainpage.xhtml', {
'app': APP,
'form': form,
'page_title': page_title,
'err_message': err_message,
'rows': rows,
'pager': Pager(start, total, reverse('szr:mainpage'), reqd, BATCH),
'total': total,
'NULL_REGISTERS': NULL_REGISTERS
})
def cron_getws2():
idx = Counter.objects.get(id='PR').number
for vec in Vec.objects.filter(id__gt=idx,
link__isnull=True).order_by('id'):
subsoup = get_ws2(vec)
if (subsoup.pocetVysledku and subsoup.cisloSenatu
and subsoup.urlDetailRizeni
and (subsoup.nazevOrganizace.string.strip()[:PREF]
== L2N[vec.idOsobyPuvodce][:PREF])):
Vec.objects.filter(id=vec.id).update(
senat=int(subsoup.cisloSenatu.string),
link=subsoup.urlDetailRizeni.string.strip())
idx = vec.id
Counter.objects.update_or_create(id='PR', defaults={'number': idx})
LOGGER.debug('WS2 information added')
def partydel(request, idx=0):
LOGGER.debug(
'Party delete page accessed using method {}, id={}'.format(
request.method, idx), request, request.POST)
uid = request.user.id
uname = request.user.username
party = get_object_or_404(Party, pk=idx, uid=uid)
if request.method == 'GET':
return render(request, 'sur_partydel.xhtml', {
'app': APP,
'page_title': 'Smazání účastníka',
'desc': party.party
})
else:
if getbutton(request) == 'yes':
LOGGER.info(
'User "{}" ({:d}) deleted party "{}"'.format(
uname, uid, party.party), request)
party.delete()
return redirect('sur:partydeleted')
return redirect('sur:mainpage')
def procdel(request, idx=0):
LOGGER.debug(
'Proceedings delete page accessed using method {}, id={}'.format(
request.method, idx), request, request.POST)
uid = request.user.id
uname = request.user.username
proc = get_object_or_404(Proceedings, pk=idx, uid=uid)
if request.method == 'GET':
return render(request, 'szr_procdel.xhtml', {
'app': APP,
'page_title': 'Smazání řízení',
'desc': proc.desc
})
else:
if getbutton(request) == 'yes':
LOGGER.info(
'User "{}" ({:d}) deleted proceedings "{}" ({})'.format(
uname, uid, proc.desc, p2s(proc)), request)
proc.delete()
return redirect('szr:procdeleted')
return redirect('szr:mainpage')
def stat():
from legal.common.utils import LOGGER
from legal.dir.models import Debtor, Discovered
now = datetime.now()
LOGGER.debug('Partial statistics generated')
return (
(
'Počet dlužníků',
Debtor.objects.count()),
(
'Počet nových dlužníků za posledních 24 hodin',
Debtor.objects.filter(timestamp_add__gte=(now - timedelta(hours=24))).count()),
(
'Počet nových dlužníků za poslední týden',
Debtor.objects.filter(timestamp_add__gte=(now - timedelta(weeks=1))).count()),
(
'Počet nových dlužníků za poslední měsíc',
Debtor.objects.filter(timestamp_add__gte=(now - timedelta(days=30))).count()),
(
'Počet dlužníků pro příští notifikaci',
Discovered.objects.filter(vec__link__isnull=False).count()),
)
def stat():
from legal.common.utils import LOGGER
from legal.sur.models import Party, Found
now = datetime.now()
LOGGER.debug('Partial statistics generated')
return (
(
'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 účastníků řízení pro příští notifikaci',
Found.objects.count()),
)
def stat():
from legal.common.utils import LOGGER
from legal.common.models import Asset
from legal.knr.models import Place, Car, Formula, Rate
LOGGER.debug('Partial statistics generated')
return (
(
'Počet míst',
Place.objects.count()),
(
'Počet vozidel',
Car.objects.count()),
(
'Počet předpisů',
Formula.objects.count()),
(
'Počet sazeb',
Rate.objects.count()),
(
'Počet položek v tabulce Asset',
Asset.objects.filter(assetid__startswith=KnrConfig.name.upper()).count()),
)
def stat():
from legal.common.utils import LOGGER
from legal.szr.models import Court, Proceedings
now = datetime.now()
LOGGER.debug('Partial statistics generated')
return (
('Počet soudů', Court.objects.count()),
('Z toho okresních soudů',
Court.objects.filter(reports__isnull=False).count()),
('Počet sledovaných řízení', Proceedings.objects.count()),
('Počet nových sledovaných řízení za posledních 24 hodin',
Proceedings.objects.filter(
timestamp_add__gte=(now - timedelta(hours=24))).count()),
('Počet nových sledovaných řízení za poslední týden',
Proceedings.objects.filter(
timestamp_add__gte=(now - timedelta(weeks=1))).count()),
('Počet nových sledovaných řízení za poslední měsíc',
Proceedings.objects.filter(
timestamp_add__gte=(now - timedelta(days=30))).count()),
('Počet sledovaných řízení pro příští notifikaci',
Proceedings.objects.filter(notify=1).count()),
)
def party(request, idx=0):
LOGGER.debug('Party information page accessed, id={}'.format(idx), request)
osoba = get_object_or_404(Osoba, id=idx)
adresy = osoba.adresy.order_by('-id')
num = 0
for adresa in adresy:
adresa.type = A2D[adresa.druhAdresy.desc]
adresa.psc = '{} {}'.format(adresa.psc[:3],
adresa.psc[3:]) if adresa.psc else ''
adresa.cl = 'even' if num % 2 else 'odd'
num += 1
return render(
request, 'pir_party.xhtml', {
'app': APP,
'page_title': 'Informace o osobě',
'subtitle': o2s(osoba),
'osoba': osoba,
'birthid':
'{}/{}'.format(osoba.rc[:6], osoba.rc[6:]) if osoba.rc else '',
'adresy': adresy
})
def debtordel(request, idx=0):
LOGGER.debug(
'Debtor delete page accessed using method {}, id={}'.format(request.method, idx),
request,
request.POST)
uid = request.user.id
uname = request.user.username
debtor = get_object_or_404(Debtor, pk=idx, uid=uid)
if request.method == 'GET':
return render(
request,
'dir_debtordel.xhtml',
{'app': APP,
'page_title': 'Smazání dlužníka',
'desc': debtor.desc})
else:
if getbutton(request) == 'yes':
LOGGER.info('User "{}" ({:d}) deleted debtor "{}"'.format(uname, uid, debtor.desc), request)
debtor.delete()
return redirect('dir:debtordeleted')
return redirect('dir:mainpage')
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()),
)
