def _get_default_select(spec):
def init_select(view, data):
sorting = view.sorting()
if sorting is None:
sorting = tuple([(k.id(), pytis.data.DESCENDANT) for k in data.key()
if view.field(k.id()) is not None])
success, select_count = pytis.form.db_operation(data.select, sort=sorting, reuse=False)
if not success:
pytis.util.log(pytis.util.EVENT, 'Selhání databázové operace')
return None
return select_count
resolver = pytis.util.resolver()
try:
view = resolver.get(spec, 'view_spec')
except:
pytis.util.log(pytis.util.OPERATIONAL, "Nepodařilo se vytvořit view_spec")
return None
from pytis.extensions import data_object
try:
data = data_object(spec)
except:
pytis.util.log(pytis.util.OPERATIONAL, "Nepodařilo se vytvořit datový objekt")
return None
data = data_object(spec)
select_count = init_select(view, data)
if select_count:
print "Default select pro specifikaci %s vrací %s řádků" % (spec, select_count,)
data.fetchone()
def delete_template(module, specification):
def s(value):
return pytis.data.Value(pytis.data.String(), value)
data_spec = self.data_spec()
view_spec = self.view_spec()
import config
data = data_spec.create(dbconnection_spec=config.dbconnection)
condition = pytis.data.AND(
pytis.data.EQ('module', s(module)),
pytis.data.EQ('specification', s(specification)))
if not data.select(condition):
message = _("Tisková sestava neexistuje: ") + specification
pytis.form.run_dialog(pytis.form.Error, message)
return
row = data.fetchone()
if data.fetchone() is not None:
message = _(
"Tisková sestava se vyskytuje ve více exemplářích: "
) + specification
pytis.form.run_dialog(pytis.form.Error, message)
return
record = pytis.presentation.PresentedRow(view_spec.fields(), data,
row)
if pytis.form.delete_record(view_spec, data, None, record):
# To update the printing button of the current form
pytis.form.refresh()
def _build_access_rights(self, object_name, connection_data):
import pytis.data
import config
access_rights = []
bindings = [
pytis.data.DBColumnBinding(name, 'pytis.access_rights', name)
for name in 'id', 'object', 'column_', 'group_', 'permission'
]
key = bindings[0]
data = pytis.data.DBDataDefault(bindings,
key,
connection_data=connection_data)
try:
data.select(condition=EQ('object', sval(object_name)))
while True:
row = data.fetchone()
if row is None:
break
access_rights.append(
(row['column_'].value(), (row['group_'].value(),
row['permission'].value())))
finally:
try:
data.close()
except:
pass
return access_rights
def delete_template(module, specification):
def s(value):
return pytis.data.Value(pytis.data.String(), value)
data_spec = self.data_spec()
view_spec = self.view_spec()
import config
data = data_spec.create(dbconnection_spec=config.dbconnection)
condition = pytis.data.AND(pytis.data.EQ('module', s(module)),
pytis.data.EQ('specification', s(specification)))
if not data.select(condition):
message = _("Tisková sestava neexistuje: ") + specification
pytis.form.run_dialog(pytis.form.Error, message)
return
row = data.fetchone()
if data.fetchone() is not None:
message = _("Tisková sestava se vyskytuje ve více exemplářích: ") + specification
pytis.form.run_dialog(pytis.form.Error, message)
return
record = pytis.presentation.PresentedRow(view_spec.fields(), data, row)
if pytis.form.delete_record(view_spec, data, None, record):
# To update the printing button of the current form
pytis.form.refresh()
def _get_default_select(spec):
def init_select(view, data):
sorting = view.sorting()
if sorting is None:
sorting = tuple([(k.id(), pytis.data.DESCENDANT)
for k in data.key()
if view.field(k.id()) is not None])
success, select_count = pytis.form.db_operation(data.select,
sort=sorting,
reuse=False)
if not success:
pytis.util.log(pytis.util.EVENT, 'Selhání databázové operace')
return None
return select_count
resolver = pytis.util.resolver()
try:
view = resolver.get(spec, 'view_spec')
except:
pytis.util.log(pytis.util.OPERATIONAL,
"Nepodařilo se vytvořit view_spec")
return None
from pytis.extensions import data_object
try:
data = data_object(spec)
except:
pytis.util.log(pytis.util.OPERATIONAL,
"Nepodařilo se vytvořit datový objekt")
return None
data = data_object(spec)
select_count = init_select(view, data)
if select_count:
print "Default select pro specifikaci %s vrací %s řádků" % (
spec,
select_count,
)
data.fetchone()
def fetch(row, direction=pytis.data.FORWARD):
result = self._data.fetchone(direction=direction)
if result is None:
# In theory this shouldn't happen but it actually happens so we
# have to attempt some workaround here.
data.rewind()
if row > 0:
data.skip(row - 1, direction=pytis.data.FORWARD)
result = data.fetchone(direction=pytis.data.FORWARD)
if result is None:
# This shouldn't happen at all but it still happens.
log(DEBUG, "Missing grid row")
if require:
raise Exception('Missing row', row)
return None
else:
log(DEBUG, "Grid data synchronization error")
self._presented_row.set_row(result)
the_row = copy.copy(self._presented_row)
self._current_row = self._CurrentRow(row, the_row)
def fetch(row, direction=pytis.data.FORWARD):
result = self._data.fetchone(direction=direction)
if result is None:
# In theory this shouldn't happen but it actually happens so we
# have to attempt some workaround here.
data.rewind()
if row > 0:
data.skip(row - 1, direction=pytis.data.FORWARD)
result = data.fetchone(direction=pytis.data.FORWARD)
if result is None:
# This shouldn't happen at all but it still happens.
log(DEBUG, "Missing grid row")
if require:
raise Exception('Missing row', row)
return None
else:
log(DEBUG, "Grid data synchronization error")
self._presented_row.set_row(result)
the_row = copy.copy(self._presented_row)
self._current_row = self._CurrentRow(row, the_row)
def crypto_admin_key(area, admin_user, connection_data):
"""Return crypto admin key for the given user and area.
The return value is a pair (KEY_ID, KEY) where KEY_ID is the database
record key and KEY is the actual key.
Arguments:
area -- name of the crypto area; basestring
admin_user -- login name of the crypto area administrator; basestring
connection_data -- database connection data; 'pytis.data.DBConnection'
instance
"""
data = crypto_key_table(connection_data)
condition = pytis.data.AND(
pytis.data.EQ('username', pytis.data.sval(admin_user)),
pytis.data.EQ('name', pytis.data.sval(area)))
if not data.select(condition):
return None, None
row = data.fetchone()
return row['key_id'], row['key']
def _build_access_rights(self, object_name, connection_data):
import pytis.data
access_rights = []
bindings = [pytis.data.DBColumnBinding(name, 'pytis.access_rights', name)
for name in 'id', 'object', 'column_', 'group_', 'permission']
key = bindings[0]
data = pytis.data.DBDataDefault(bindings, key,
connection_data=connection_data)
try:
data.select(condition=EQ('object', sval(object_name)))
while True:
row = data.fetchone()
if row is None:
break
access_rights.append((row['column_'].value(),
(row['group_'].value(),
row['permission'].value())))
finally:
try:
data.close()
except:
pass
return access_rights
def check_data(self, spec_name):
errors = []
resolver = self._resolver
try:
data_spec = resolver.get(spec_name, 'data_spec')
except pytis.util.ResolverError as e:
return errors + [str(e)]
try:
view_spec = resolver.get(spec_name, 'view_spec')
fields = view_spec.fields()
success, data = pytis.form.db_operation(data_spec.create,
dbconnection_spec=self._dbconn)
if not success:
return errors + ["Nepodařilo se vytvořit datový objekt."]
try:
data.select(limit=1)
try:
row = data.fetchone()
except AssertionError as e:
# Hack to avoid printing errors on non-existent image files
# referred from the database.
if ((len(e.args) == 3 and
isinstance(e.args[2], pytis.data.ValidationError) and
e.args[2][0] == u'Neplatný grafický formát')):
row = None
else:
raise
finally:
try:
data.close()
except:
pass
if row:
pytis.presentation.PresentedRow(fields, data, row)
except Exception as e:
errors.append(str(e))
return errors
def check_data(self, spec_name):
errors = []
resolver = self._resolver
try:
data_spec = resolver.get(spec_name, 'data_spec')
except pytis.util.ResolverError as e:
return errors + [str(e)]
try:
view_spec = resolver.get(spec_name, 'view_spec')
fields = view_spec.fields()
success, data = pytis.form.db_operation(
data_spec.create, dbconnection_spec=self._dbconn)
if not success:
return errors + ["Nepodařilo se vytvořit datový objekt."]
try:
data.select(limit=1)
try:
row = data.fetchone()
except AssertionError as e:
# Hack to avoid printing errors on non-existent image files
# referred from the database.
if ((len(e.args) == 3
and isinstance(e.args[2], pytis.data.ValidationError)
and e.args[2][0] == u'Neplatný grafický formát')):
row = None
else:
raise
finally:
try:
data.close()
except:
pass
if row:
pytis.presentation.PresentedRow(fields, data, row)
except Exception as e:
errors.append(str(e))
return errors
def dbselect(spec, condition=None, sort=(), transaction=None, arguments={}):
"""Vrať řádky dané db tabulky jako sekvenci.
Argumenty:
spec -- název specifikace datového objektu nebo přímo instance třídy
'pytis.data.DataFactory'
condition, sort, transaction -- argumenty volání
'pytis.data.postgresql.select()'.
Vrací všechny řádky vrácené z databáze jako list.
"""
data = data_object(spec)
data.select(condition=condition, sort=sort, transaction=transaction,
arguments=arguments)
result = []
while True:
row = data.fetchone()
if row is None:
data.close()
break
result.append(row)
return result
def table_row(*args, **kwargs):
row = data.fetchone(transaction=transaction)
if row is None:
return None
presented_row.set_row(row)
return [presented_row.format(c.id, secure=True) for c in columns]
def table_row(*args, **kwargs):
row = data.fetchone(transaction=transaction)
if row is None:
return None
presented_row.set_row(row)
return [presented_row.format(c.id, secure=True) for c in columns]
def lfunction():
data.select(transaction=transaction)
self._row = data.fetchone()
data.close()
