from pytigon_lib.schviews.form_fun import form_with_perms
from pytigon_lib.schviews.viewtools import dict_to_template, dict_to_odf, dict_to_pdf, dict_to_json, dict_to_xml
from pytigon_lib.schviews.viewtools import render_to_response
from pytigon_lib.schdjangoext.tools import make_href
from django.utils.translation import ugettext_lazy as _
from . import models
import os
import sys
import datetime
from django.template import Context, Template
PFORM = form_with_perms('projekty')
class _FilterFormProjektNawierzchni(forms.Form):
projektant = forms.ChoiceField(label=_('Projektanci'),
required=True,
choices=models.lista_projektant)
def process(self, request, queryset=None):
projektant = self.cleaned_data['projektant']
if projektant:
if projektant == 'Wszystkie':
pass
elif projektant == 'Tylko moje':
queryset = queryset.filter(
from django.utils.translation import ugettext_lazy as _
from . import models
import os
import sys
import datetime
import time
from pytigon_lib.schdjangoext.tools import import_model
from pyexcel_odsr import get_data
from pytigon_lib.schtools.schjson import json_dumps, json_loads
from pytigon_lib.schfs.vfstools import get_temp_filename
import openpyxl
import csv
PFORM = form_with_perms('schtools')
class ImportTableForm(forms.Form):
import_file = forms.FileField(
label=_('File to import'),
required=True,
)
def view_importtableform(request, *argi, **argv):
return PFORM(request, ImportTableForm, 'schtools/formimporttableform.html',
{})
def autocomplete_search(request, type):
ret.append([ysymkar, parts[-1], symkar, row[1].value, row[2].value, row[3].value, row[4].value, row[5].value, row[6].value ] )
else:
break
for pos in ret:
if not is_in_database(pos[0]):
insert_tkw(pos[0], pos[1], pos[2], float(pos[3]), float(pos[4]), float(pos[5]), float(pos[6]), float(pos[7]), float(pos[8]))
ret_messages.append(("Insert:", pos[1:]))
else:
update_tkw(pos[0], pos[1], pos[2], float(pos[3]), float(pos[4]), float(pos[5]), float(pos[6]), float(pos[7]), float(pos[8]))
ret_messages.append(("Update:", pos[1:]))
return ret_messages
PFORM = form_with_perms('qlikview')
class QlikViewUploadForm(forms.Form):
qlikview_file = forms.FileField(label=_('xls[x]'), required=True, )
def process(self, request, queryset=None):
return {}
def render_to_response(self, request, template, context_instance):
firma = None
if 'firm' in request.GET:
firma = request.GET['firm']
from pytigon_lib.schdjangoext.tools import make_href
from django.utils.translation import ugettext_lazy as _
from . import models
import os
import sys
import datetime
import configparser
import zipfile
from pytigon_lib.schfs.vfstools import get_temp_filename
from pytigon_lib.schtools.install import extract_ptig
PFORM = form_with_perms('schinstall')
class upload_ptig(forms.Form):
status = forms.CharField(label=_('Status'), required=False, max_length=None, min_length=None)
ptig = forms.FileField(label=_('Pytigon install file (*.ptig)'), required=False, widget=forms.ClearableFileInput(attrs={'accept': '.ptig'}))
accept_license = forms.BooleanField(label=_('Accept license'), required=False, initial=False,)
def process(self, request, queryset=None):
status = self.cleaned_data['status']
if status:
if status == '1':
if 'INSTALL_FILE_NAME' in request.session:
file_name = request.session['INSTALL_FILE_NAME']
archive = zipfile.ZipFile(file_name, 'r')
from . import models
import os
import sys
import datetime
import json
from django.http import HttpResponseRedirect, HttpResponse, HttpResponseBadRequest
from .models import history
from pytigon_lib.schhttptools import httpclient
from html.parser import HTMLParser
import re
from pytigon_lib.schtasks.task import get_process_manager
from pytigon_lib.schhttptools import httpclient
PFORM = form_with_perms('schbrowser')
class MultiDownload(forms.Form):
base_address = forms.CharField(
label=_('Base address'),
required=True,
initial='http://learningenglish.voanews.com',
max_length=None,
min_length=None)
source_page = forms.CharField(
label=_('Source page'),
required=False,
initial=
'/archive/learningenglish-programs-radio-in-the-news/latest/1577/1577.html',
max_length=None,
form = None
return {
'error': False,
'form': form,
'doc_head': doc_head,
'doc_type': doc_type,
'doc_reg': doc_reg,
'reg_status': reg_status,
'action_name': action_name,
'description': description
}
else:
return {'error': "Status %s doesn't exists" % action_name}
PFORM = form_with_perms('schelements')
class _FilterFormDocHead(forms.Form):
date_from = forms.DateField(
label=_('Date from'),
required=True,
initial=year_ago,
)
date_to = forms.DateField(
label=_('Data to'),
required=True,
)
target = forms.CharField(label=_('Target'),
required=False,
max_length=None,
from pytigon_lib.schviews.viewtools import dict_to_template, dict_to_odf, dict_to_pdf, dict_to_json, dict_to_xml
from pytigon_lib.schviews.viewtools import render_to_response
from pytigon_lib.schdjangoext.tools import make_href
from django.utils.translation import ugettext_lazy as _
from . import models
import os
import sys
import datetime
from pytigon_lib.schtable.vfstable import vfstable_view, vfsopen, vfssave, vfsopen_page
from schtools.models import Parameter
import django.contrib.auth
PFORM = form_with_perms('schcommander')
class FileManager(forms.Form):
folder = forms.CharField(
label=_('Folder'),
required=True,
)
sort = forms.ChoiceField(label=_('Sort'),
required=True,
choices=models.file_manager_sort_choices)
def view_filemanager(request, *argi, **argv):
return PFORM(request, FileManager, 'schcommander/formfilemanager.html', {})
import sys
import datetime
from pytigon_lib.schfs.vfstools import get_temp_filename
from pytigon_lib.schdjangoext.spreadsheet_render import render_to_response_odf
class y(object):
name = "Hello world!"
class x(object):
stanowisko = y()
PFORM = form_with_perms('schodfupload')
class OdfUploadForm(forms.Form):
odf_file = forms.FileField(
label=_('Odf file'),
required=True,
)
def process(self, request, queryset=None):
return {'object': x()}
def render_to_response(self, request, template, context_instance):
odfdata = request.FILES['odf_file']
file_name = get_temp_filename("temp.ods")
from pytigon_lib.schviews.viewtools import dict_to_template, dict_to_odf, dict_to_pdf, dict_to_json, dict_to_xml
from pytigon_lib.schviews.viewtools import render_to_response
from pytigon_lib.schdjangoext.tools import make_href
from django.utils.translation import ugettext_lazy as _
from . import models
import os
import sys
import datetime
from django.http import HttpResponse
from pytigon_lib.schtasks.base_task import get_process_manager
from pytigon_lib.schtools.schjson import json_dumps, json_loads
PFORM = form_with_perms('schtasks')
class TaskListForm(forms.Form):
time_from = forms.DateTimeField(
label=_('Time from'),
required=False,
)
time_to = forms.DateTimeField(
label=_('Time to'),
required=False,
)
only_my = forms.NullBooleanField(
label=_('Only my'),
required=False,
)
from crh.models import Ad
def check(val1, val2):
if val1 == val2:
return [val1, True]
elif not val1:
if val2 == '[]':
return ["", True]
else:
return [val2, True]
else:
return [val1, False]
PFORM = form_with_perms('config')
class employee_import(forms.Form):
import_file = forms.FileField(
label=_('Import employes (*.xlsx)'),
required=True,
)
def process(self, request, queryset=None):
object_list = []
data = request.FILES['import_file']
tmp_dir = gettempdir()
file_name = os.path.join(tmp_dir, "employees.xlsx")
with open(file_name, "wb") as f:
if value:
return value
return ""
def int_key_from_str(v):
try:
ret = int(v)
except:
ret = 0
return ret
def key_for_autoryz(v):
return key.split('/')[3]
PFORM = form_with_perms('prawa')
class __FilterFormOperator(forms.Form):
nazwisko = forms.CharField(label=_('Nazwisko'), required=True, )
def view___filterformoperator(request, *argi, **argv):
return PFORM(request, __FilterFormOperator, 'prawa/form__filterformoperator.html', {})
class GrupyFunkcjeForm(forms.Form):
pdf = forms.BooleanField(label=_('Do pdf'), required=False, initial=False,)
return self._replace_proc(self.settings.p7)
def p8(self):
return self._replace_proc(self.settings.p8)
def get_oddz_from_name(oddz):
conf = models.Config.objects.all()
x = oddz[:3].upper()
for pos in conf:
if pos.nazwa[:3].upper() == x:
return "%02d" % pos.nr_oddz
return '50'
PFORM = form_with_perms('produkcja')
class ProdukcjaForm(forms.Form):
rok = forms.ChoiceField(label=_('Rok'),
required=True,
initial='2016',
choices=models.Rok_CHOICES)
mies = forms.ChoiceField(label=_('Miesiąc'),
required=True,
initial='01',
choices=models.Miesiac_CHOICES)
ods_wzr = forms.FileField(
label=_('Plik[i] z oddziału[ów]'),
required=False,
)
from pytigon_lib.schviews.viewtools import dict_to_template, dict_to_odf, dict_to_pdf, dict_to_json, dict_to_xml
from pytigon_lib.schviews.viewtools import render_to_response
from pytigon_lib.schdjangoext.tools import make_href
from django.utils.translation import ugettext_lazy as _
from . import models
import os
import sys
import datetime
import time
import requests
from pytigon_lib.schtools.schjson import json_dumps, json_loads
PFORM = form_with_perms('sprzedaz')
class LoadKalkulatorData(forms.Form):
data = forms.FileField(
label=_('Dane zasilające kalkulator'),
required=True,
)
def view_loadkalkulatordata(request, *argi, **argv):
return PFORM(request, LoadKalkulatorData,
'sprzedaz/formloadkalkulatordata.html', {})
def rebuild(request):
order = obj2.order
if obj.order < order:
objects = models.Report.objects.filter(parent=obj.parent).filter(
order__gt=obj2.order).update(order=F('order') + 2)
obj.order = order + 1
else:
objects = models.Report.objects.filter(parent=obj.parent).filter(
order__gte=obj2.order).update(order=F('order') + 2)
obj.order = order
obj.save()
url = make_path('ok')
return HttpResponseRedirect(url)
PFORM = form_with_perms('schreports')
class _FilterFormReport(forms.Form):
date_from = forms.DateField(
label=_('Data od'),
required=None,
initial=year_ago,
)
date_to = forms.DateField(
label=_('Data do'),
required=True,
)
def process(self, request, queryset=None):
f.parent=app
f.save()
statics_array=prj[2]
for static in statics_array:
s = models.SChStatic(**array_dict(static, static_attr))
s.parent=prj_instence
s.save()
object_list.append((datetime.datetime.now().time().isoformat(), 'SUCCESS:', ""))
return { 'object_list': reversed(object_list) }
PFORM = form_with_perms('schbuilder')
class Installer(forms.Form):
name = forms.ChoiceField(label=_('Application package name'), required=True, choices=models.apppack)
def process(self, request, queryset=None):
name = self.cleaned_data['name']
return installer(request, name)
def view_installer(request, *argi, **argv):
return PFORM(request, Installer, 'schbuilder/forminstaller.html', {})
from pytigon_lib.schviews.form_fun import form_with_perms
from pytigon_lib.schviews.viewtools import dict_to_template, dict_to_odf, dict_to_pdf, dict_to_json, dict_to_xml
from pytigon_lib.schviews.viewtools import render_to_response
from pytigon_lib.schdjangoext.tools import make_href
from django.utils.translation import ugettext_lazy as _
from . import models
import os
import sys
import datetime
PFORM = form_with_perms('schsimplecontrolsdemo')
class TestForm(forms.Form):
test_field_1 = forms.CharField(label=_('Test field 1'), required=True, )
test_field_2 = forms.BooleanField(label=_('Test field 2'), required=True, )
test_field_3 = forms.DateField(label=_('Test field 3'), required=True, )
test_field_4 = forms.EmailField(label=_('Test field 4'), required=False, )
integer_field = forms.IntegerField(label=_('Integer field'), required=True, )
float_field = forms.FloatField(label=_('FloatField'), required=True, )
def process(self, request, queryset=None):
object_list = [
[1,2,3,4,5,6,7,8],
[1,2,3,4,5,6,7,8],
