def write_actions(self, model_name, icon_name, item_actions):
viewer_file = join(
dirname(self.full_modulepath), 'views_%s.py' % model_name.lower())
is_new = not isfile(viewer_file)
with open(viewer_file, 'ab') as self.viewfile:
self._write_header(model_name, item_actions, is_new)
class_inst = getattr(self.module_obj, model_name)
verbose_name = six.text_type(class_inst._meta.verbose_name)
verbose_name_plural = six.text_type(
class_inst._meta.verbose_name_plural)
for item_name in sorted(list(item_actions.keys())):
acts = item_actions[item_name]
actions, caption, right, menuext = self._define_params(model_name, item_name, acts, verbose_name, verbose_name_plural)
if item_name == '3Transition':
loop = []
for field in class_inst._meta.get_fields():
if isinstance(field, FSMFieldMixin):
loop.append({'statname': field.name})
six.print_(loop)
else:
loop = [{'statname': ''}]
for item in loop:
actions = actions % item
self.writedata("""
%(actions)s
@MenuManage.describ('%(right)s'%(menuext)s)
class %(modelname)s%(itemname)s(%(classname)s):
icon = "%(iconname)s"
model = %(modelname)s
field_id = '%(fieldidname)s'
%(caption)s
""" % {'modelname': model_name, 'iconname': icon_name, 'fieldidname': model_name.lower(), 'itemname': item_name[1:],
'classname': LIST_VIEWER[item_name][0], 'actions': actions, 'caption': caption, 'right': right, 'menuext': menuext})
showinfo("View generator", "Views generated in %s" % os.path.relpath(viewer_file, self.project_path))
def upgrade(self):
self.btnupgrade.config(state=DISABLED)
self.instance_list.config(state=DISABLED)
try:
from logging import getLogger
admin_path = import_module(
"lucterios.install.lucterios_admin").__file__
proc = Popen(
[sys.executable, admin_path, "update"], stderr=STDOUT, stdout=PIPE)
value = proc.communicate()[0]
try:
value = value.decode('ascii')
except:
pass
six.print_(value)
if proc.returncode != 0:
getLogger("lucterios.admin").error(value)
else:
getLogger("lucterios.admin").info(value)
showinfo(ugettext("Lucterios installer"), ugettext(
"The application must restart"))
python = sys.executable
os.execl(python, python, *sys.argv)
finally:
self._refresh_modules()
self.btnupgrade.config(state=NORMAL)
self.instance_list.config(state=NORMAL)
def _destroy_test_db(self, test_database_name, verbosity=1):
"""
Drop the test databases using a connection to database 'master'.
"""
if not self._test_database_create(settings):
if verbosity >= 1:
six.print_("Skipping Test DB destruction")
return
for alias in connections:
connections[alias].close()
try:
with self._nodb_connection.cursor() as cursor:
qn_db_name = self.connection.ops.quote_name(test_database_name)
# boot all other connections to the database, leaving only this
# connection
cursor.execute(
"ALTER DATABASE %s SET SINGLE_USER WITH ROLLBACK IMMEDIATE" % qn_db_name)
time.sleep(1)
# database is now clear to drop
cursor.execute("DROP DATABASE %s" % qn_db_name)
except Exception:
# if 'it is currently in use' in str(e):
# six.print_('Cannot drop database %s because it is in use' % test_database_name)
# else:
six.reraise(*sys.exc_info())
def get_actions(cls, ident, xfer, model_name=None, key=None, **args):
cls._actlock.acquire()
try:
acts = []
if model_name is None:
model_name = xfer.model.get_long_name()
if model_name in cls._ACTION_LIST.keys():
for act_ident, act_xclass, act_title, act_icon, act_condition, act_options in cls._ACTION_LIST[
model_name]:
try:
if (act_ident
== ident) and ((act_condition is None)
or act_condition(xfer, **args)):
acts.append(
(act_xclass.get_action(act_title, act_icon),
dict(act_options)))
except Exception:
six.print_(
'error for [%s,%s,%s,%s]' %
(act_ident, act_xclass, act_title, act_icon))
raise
if key is not None:
acts.sort(key=key)
for act in acts:
for remove_opt in ['intop', 'model_name']:
if remove_opt in act[1]:
del act[1][remove_opt]
return acts
finally:
cls._actlock.release()
def upgrade(self):
self.btnupgrade.config(state=DISABLED)
self.instance_list.config(state=DISABLED)
try:
from logging import getLogger
admin_path = import_module(
"lucterios.install.lucterios_admin").__file__
proc = Popen([sys.executable, admin_path, "update"],
stderr=STDOUT,
stdout=PIPE)
value = proc.communicate()[0]
try:
value = value.decode('ascii')
except Exception:
pass
six.print_(value)
if proc.returncode != 0:
getLogger("lucterios.admin").error(value)
else:
getLogger("lucterios.admin").info(value)
showinfo(ugettext_lazy("Lucterios launcher"),
ugettext_lazy("The application must restart"))
python = sys.executable
os.execl(python, python, *sys.argv)
finally:
self._refresh_modules()
self.btnupgrade.config(state=NORMAL)
self.instance_list.config(state=NORMAL)
def write_actions(self, model_name, icon_name, item_actions):
viewer_file = join(
dirname(self.full_modulepath), 'views_%s.py' % model_name.lower())
is_new = not isfile(viewer_file)
with open(viewer_file, 'ab') as self.viewfile:
self._write_header(model_name, item_actions, is_new)
class_inst = getattr(self.module_obj, model_name)
verbose_name = six.text_type(class_inst._meta.verbose_name)
verbose_name_plural = six.text_type(
class_inst._meta.verbose_name_plural)
for item_name in sorted(list(item_actions.keys())):
acts = item_actions[item_name]
actions, caption, right, menuext = self._define_params(model_name, item_name, acts, verbose_name, verbose_name_plural)
if item_name == '3Transition':
loop = []
for field in class_inst._meta.get_fields():
if isinstance(field, FSMFieldMixin):
loop.append({'statname': field.name})
six.print_(loop)
else:
loop = [{'statname': ''}]
for item in loop:
actions = actions % item
self.writedata("""
%(actions)s
@MenuManage.describ('%(right)s'%(menuext)s)
class %(modelname)s%(itemname)s(%(classname)s):
icon = "%(iconname)s"
model = %(modelname)s
field_id = '%(fieldidname)s'
%(caption)s
""" % {'modelname': model_name, 'iconname': icon_name, 'fieldidname': model_name.lower(), 'itemname': item_name[1:],
'classname': LIST_VIEWER[item_name][0], 'actions': actions, 'caption': caption, 'right': right, 'menuext': menuext})
showinfo("View generator", "Views generated in %s" % os.path.relpath(viewer_file, self.project_path))
def fillresponse(self):
if "SAVE" in self.params.keys():
del self.params["SAVE"]
if self.has_changed:
self.item.editor.before_save(self)
try:
self.item.save()
self.has_changed = False
if self.fill_manytomany_fields():
self.item.save()
except IntegrityError as err:
getLogger("lucterios.core.container").info("%s", err)
six.print_(err)
self.raise_except(_("This record exists yet!"),
self.raise_except_class)
if self.except_msg == '':
self.item.editor.saving(self)
if self.getparam('URL_TO_REDIRECT') is not None:
url_text = self.getparam('URL_TO_REDIRECT')
self.redirect_action(WrapAction('', '', url_text=url_text),
params={self.field_id: self.item.id})
elif isinstance(self.redirect_to_show, six.text_type):
self.redirect_action(ActionsManage.get_action_url(
self.model.get_long_name(), self.redirect_to_show, self),
params={self.field_id: self.item.id})
def migrate_containers(old_parent, new_parent):
nb_folder = 0
nb_doc = 0
for old_document in Document.objects.filter(folder=old_parent):
new_doc = DocumentContainer(parent=new_parent, name=old_document.name, description=old_document.description)
new_doc.modifier = old_document.modifier
new_doc.date_modification = old_document.date_modification
new_doc.creator = old_document.creator
new_doc.date_creation = old_document.date_creation
new_doc.save()
new_doc.content = old_document.content
nb_doc += 1
for old_folder in Folder.objects.filter(parent=old_parent):
new_folder = FolderContainer.objects.create(parent=new_parent, name=old_folder.name, description=old_folder.description)
new_folder.viewer.set(old_folder.viewer.all())
new_folder.modifier.set(old_folder.modifier.all())
sub_nb_folder, sub_nb_doc = migrate_containers(old_folder, new_folder)
old_folder.delete()
nb_folder += sub_nb_folder
nb_doc += sub_nb_doc
nb_folder += 1
if (old_parent is None) and (nb_folder > 0):
six.print_('Convert containers: folder=%d - documents=%d' % (nb_folder, nb_doc))
return nb_folder, nb_doc
def _destroy_test_db(self, test_database_name, verbosity=1):
"""
Drop the test databases using a connection to database 'master'.
"""
if not self._test_database_create(settings):
if verbosity >= 1:
six.print_("Skipping Test DB destruction")
return
for alias in connections:
connections[alias].close()
try:
with self._nodb_connection.cursor() as cursor:
qn_db_name = self.connection.ops.quote_name(test_database_name)
# boot all other connections to the database, leaving only this connection
cursor.execute(
"ALTER DATABASE %s SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
% qn_db_name)
time.sleep(1)
# database is now clear to drop
cursor.execute("DROP DATABASE %s" % qn_db_name)
except Exception:
# if 'it is currently in use' in str(e):
# six.print_('Cannot drop database %s because it is in use' % test_database_name)
# else:
six.reraise(*sys.exc_info())
def assert_action_equal(self, path, act_desc):
self.assertTrue(self.response_json is not None)
act = path
if isinstance(path, six.text_type):
act = self.get_json_path(path)
self.assertEqual(act['text'], act_desc[0])
if act_desc[1] is None:
self.assertTrue('icon' not in act.keys())
elif act_desc[1].startswith('images/'):
self.assertEqual(act['icon'],
'/static/lucterios.CORE/' + act_desc[1])
else:
self.assertEqual(act['icon'], '/static/' + act_desc[1])
if len(act_desc) > 2:
self.assertEqual(act['extension'], act_desc[2])
self.assertEqual(act['action'], act_desc[3])
self.assertEqual(act['close'], six.text_type(act_desc[4]))
self.assertEqual(act['modal'], six.text_type(act_desc[5]))
self.assertEqual(act['unique'], six.text_type(act_desc[6]))
if len(act_desc) > 7:
try:
for key, value in act_desc[7].items():
self.assertEqual(six.text_type(act['params'][key]),
six.text_type(value))
except Exception:
six.print_(six.text_type(act['params']))
raise
else:
self.assertTrue('extension' not in act.keys())
self.assertTrue('action' not in act.keys())
self.assertEqual(path['close'], six.text_type(1))
self.assertEqual(path['modal'], six.text_type(1))
self.assertEqual(path['unique'], six.text_type(1))
def assert_action_equal(self, path, act_desc):
self.assertTrue(self.response_json is not None)
act = path
if isinstance(path, six.text_type):
act = self.get_json_path(path)
self.assertEqual(act['text'], act_desc[0])
if act_desc[1] is None:
self.assertTrue('icon' not in act.keys())
elif act_desc[1].startswith('images/'):
self.assertEqual(act['icon'], '/static/lucterios.CORE/' + act_desc[1])
else:
self.assertEqual(act['icon'], '/static/' + act_desc[1])
if len(act_desc) > 2:
self.assertEqual(act['extension'], act_desc[2])
self.assertEqual(act['action'], act_desc[3])
self.assertEqual(act['close'], six.text_type(act_desc[4]))
self.assertEqual(act['modal'], six.text_type(act_desc[5]))
self.assertEqual(act['unique'], six.text_type(act_desc[6]))
if len(act_desc) > 7:
try:
for key, value in act_desc[7].items():
self.assertEqual(six.text_type(act['params'][key]), six.text_type(value))
except Exception:
six.print_(six.text_type(act['params']))
raise
else:
self.assertTrue('extension' not in act.keys())
self.assertTrue('action' not in act.keys())
self.assertEqual(path['close'], six.text_type(1))
self.assertEqual(path['modal'], six.text_type(1))
self.assertEqual(path['unique'], six.text_type(1))
def run(self):
try:
self._params()
self._thirds()
self._years()
self._costaccounting()
self._chartsaccount()
self._entryaccount()
self._model()
except:
import traceback
traceback.print_exc()
six.print_("*** Unexpected error: %s ****" % sys.exc_info()[0])
self.print_info("Nb thirds:%d", len(self.third_list))
self.print_info("Nb fiscal years:%d", len(self.year_list))
self.print_info(
"Nb chart of accounts:%d", len(self.chartsaccount_list))
self.print_info(
"Nb entries of account:%d", len(self.entryaccount_list))
self.print_info(
"Nb cost accountings:%d", len(self.costaccounting_list))
self.old_db.objectlinks['third'] = self.third_list
self.old_db.objectlinks['year'] = self.year_list
self.old_db.objectlinks['costaccounting'] = self.costaccounting_list
self.old_db.objectlinks['chartsaccount'] = self.chartsaccount_list
self.old_db.objectlinks['journal'] = self.journal_list
self.old_db.objectlinks['entryaccount'] = self.entryaccount_list
def print_xml(self, xpath):
self.assertTrue(self.response_xml is not None)
xml_value = self.get_first_xpath(xpath)
six.print_(
etree.tostring(xml_value,
xml_declaration=True,
pretty_print=True,
encoding='utf-8').decode("utf-8"))
def print_json(self, path=None):
from django.core.serializers.json import DjangoJSONEncoder
import json
if path is None:
path = self.response_json
elif isinstance(path, six.text_type):
path = self.get_json_path(path)
six.print_(json.dumps(path, cls=DjangoJSONEncoder, indent=3))
def print_json(self, path=None):
from django.core.serializers.json import DjangoJSONEncoder
import json
if path is None:
path = self.response_json
elif isinstance(path, six.text_type):
path = self.get_json_path(path)
six.print_(json.dumps(path, cls=DjangoJSONEncoder, indent=3))
def post_after_migrate(sender, **kwargs):
if ('exception' not in kwargs) and ('app_config' in kwargs) and (
kwargs['app_config'].name == 'lucterios.CORE'):
from django.conf import settings
set_locale_lang(settings.LANGUAGE_CODE)
six.print_('check parameters')
Signal.call_signal("checkparam")
six.print_('convert data')
Signal.call_signal("convertdata")
def _rewrite_file(self, filename):
change_count = 0
with fileinput.FileInput(filename, inplace=True) as f:
for original_line in f:
line = self._rewrite_line(original_line)
print_(line, end='') # NOQA
if line != original_line:
change_count += 1
return change_count
def test_scheduler(self):
six.print_('-- Begin test_scheduler --')
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_grid_equal('tasks', {
"name": "nom",
"trigger": "déclencheur",
"nextdate": "date suivante"
}, 0)
self.calljson('/lucterios.dummy/addSchedulerTask', {})
self.assert_observer('core.acknowledge', 'lucterios.dummy',
'addSchedulerTask')
value = Params.getvalue('dummy-value')
self.assertEqual(value, "")
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_count_equal('tasks', 1)
self.assert_json_equal('', 'tasks/@0/name', 'Run simple action')
self.assert_json_equal('', 'tasks/@0/trigger', 'interval[0:00:10]')
self.assert_json_equal('', 'tasks/@0/nextdate',
datetime.now().strftime('%Y-%m-%dT%H:'), True)
sleep(6 * 10 + .2)
value = Params.getvalue('dummy-value')
self.assertEqual(len(value.split('{[br/]}')), 5)
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_count_equal('tasks', 1)
self.assert_json_equal('', 'tasks/@0/name', 'Run simple action')
self.assert_json_equal(
'', 'tasks/@0/trigger',
'date[' + datetime.now().strftime('%Y-%m-%d %H:'), True)
self.assert_json_equal('', 'tasks/@0/nextdate',
datetime.now().strftime('%Y-%m-%dT%H:'), True)
sleep(10 + .2)
value = Params.getvalue('dummy-value')
self.assertEqual(value, "")
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_count_equal('tasks', 0)
six.print_('-- End test_scheduler --')
def run(self):
try:
self._params()
self._config()
self._event()
self._degree()
except:
import traceback
traceback.print_exc()
six.print_("*** Unexpected error: %s ****" % sys.exc_info()[0])
self.print_info("Nb degree types:%d", len(self.degreetype_list))
self.print_info("Nb sub degree types:%d", len(self.subdegreetype_list))
self.print_info("Nb degrees:%d", len(self.degree_list))
def print_info(self, msg, arg):
if self.old_db.log_file is None:
stdout = sys.stdout
else:
stdout = io.open(self.old_db.log_file, mode="a", encoding='utf-8')
try:
text = msg % arg
six.print_(text, file=stdout)
except UnicodeEncodeError:
pass
finally:
if self.old_db.log_file is not None:
stdout.close()
def run(self):
try:
self._params()
self._setowner()
self._callfunds()
self._expense()
self._payoff()
except:
import traceback
traceback.print_exc()
six.print_("*** Unexpected error: %s ****" % sys.exc_info()[0])
self.print_info("Nb owners:%d", len(self.owner_list))
self.print_info("Nb sets:%d", len(self.set_list))
self.print_info("Nb calls of funds:%d", len(self.callfunds_list))
self.print_info("Nb expenses:%d", len(self.expense_list))
def run(self):
try:
self._params()
self._season()
self._subscription()
self._categories()
self._adherents()
except:
import traceback
traceback.print_exc()
six.print_("*** Unexpected error: %s ****" % sys.exc_info()[0])
self.print_info("Nb seasons:%d", len(self.season_list))
self.print_info("Nb adherents:%d", len(self.adherent_list))
self.print_info("Nb subscriptions:%d", len(self.subscription_list))
self.old_db.objectlinks['activity'] = self.activity_list
self.old_db.objectlinks['adherent'] = self.adherent_list
def run(self):
try:
self._params()
self._vat()
self._article()
self._bill()
self._payoff()
self._deposit()
except:
import traceback
traceback.print_exc()
six.print_("*** Unexpected error: %s ****" % sys.exc_info()[0])
self.print_info("Nb articles:%d", len(self.article_list))
self.print_info("Nb bills:%d", len(self.bill_list))
self.old_db.objectlinks['article'] = self.article_list
self.old_db.objectlinks['bill'] = self.bill_list
def runshell_db(cls, conn_params):
args = [cls.executable_name]
host = conn_params.get('host', '')
port = conn_params.get('port', '')
dbname = conn_params.get('database', '')
user = conn_params.get('user', '')
passwd = conn_params.get('password', '')
if user:
args += ['-U', user]
if host:
args += ['-h', host]
if port:
args += ['-p', str(port)]
args += [dbname]
temp_pgpass = None
try:
if passwd:
# Create temporary .pgpass file.
temp_pgpass = NamedTemporaryFile(mode='w+')
try:
print_(
_escape_pgpass(host) or '*',
str(port) or '*',
_escape_pgpass(dbname) or '*',
_escape_pgpass(user) or '*',
_escape_pgpass(passwd),
file=temp_pgpass,
sep=':',
flush=True,
)
os.environ['PGPASSFILE'] = temp_pgpass.name
except UnicodeEncodeError:
# If the current locale can't encode the data, we let
# the user input the password manually.
pass
subprocess.check_call(args)
finally:
if temp_pgpass:
temp_pgpass.close()
if 'PGPASSFILE' in os.environ: # unit tests need cleanup
del os.environ['PGPASSFILE']
def runshell_db(cls, settings_dict):
args = [cls.executable_name]
host = settings_dict.get('HOST', '')
port = settings_dict.get('PORT', '')
name = settings_dict.get('NAME', '')
user = settings_dict.get('USER', '')
passwd = settings_dict.get('PASSWORD', '')
if user:
args += ['-U', user]
if host:
args += ['-h', host]
if port:
args += ['-p', str(port)]
args += [name]
temp_pgpass = None
try:
if passwd:
# Create temporary .pgpass file.
temp_pgpass = NamedTemporaryFile(mode='w+')
try:
print_(
_escape_pgpass(host) or '*',
str(port) or '*',
_escape_pgpass(name) or '*',
_escape_pgpass(user) or '*',
_escape_pgpass(passwd),
file=temp_pgpass,
sep=':',
flush=True,
)
os.environ['PGPASSFILE'] = temp_pgpass.name
except UnicodeEncodeError:
# If the current locale can't encode the data, we let
# the user input the password manually.
pass
subprocess.call(args)
finally:
if temp_pgpass:
temp_pgpass.close()
if 'PGPASSFILE' in os.environ: # unit tests need cleanup
del os.environ['PGPASSFILE']
def runshell_db(cls, conn_params):
args = [cls.executable_name]
host = conn_params.get("host", "")
port = conn_params.get("port", "")
dbname = conn_params.get("database", "")
user = conn_params.get("user", "")
passwd = conn_params.get("password", "")
if user:
args += ["-U", user]
if host:
args += ["-h", host]
if port:
args += ["-p", str(port)]
args += [dbname]
temp_pgpass = None
try:
if passwd:
# Create temporary .pgpass file.
temp_pgpass = NamedTemporaryFile(mode="w+")
try:
print_(
_escape_pgpass(host) or "*",
str(port) or "*",
_escape_pgpass(dbname) or "*",
_escape_pgpass(user) or "*",
_escape_pgpass(passwd),
file=temp_pgpass,
sep=":",
flush=True,
)
os.environ["PGPASSFILE"] = temp_pgpass.name
except UnicodeEncodeError:
# If the current locale can't encode the data, we let
# the user input the password manually.
pass
subprocess.call(args)
finally:
if temp_pgpass:
temp_pgpass.close()
if "PGPASSFILE" in os.environ: # unit tests need cleanup
del os.environ["PGPASSFILE"]
def runshell_db(cls, conn_params):
args = [cls.executable_name]
host = conn_params.get('host', '')
port = conn_params.get('port', '')
dbname = conn_params.get('database', '')
user = conn_params.get('user', '')
passwd = conn_params.get('password', '')
if user:
args += ['-U', user]
if host:
args += ['-h', host]
if port:
args += ['-p', str(port)]
args += [dbname]
temp_pgpass = None
try:
if passwd:
# Create temporary .pgpass file.
temp_pgpass = NamedTemporaryFile(mode='w+')
try:
print_(
_escape_pgpass(host) or '*',
str(port) or '*',
_escape_pgpass(dbname) or '*',
_escape_pgpass(user) or '*',
_escape_pgpass(passwd),
file=temp_pgpass,
sep=':',
flush=True,
)
os.environ['PGPASSFILE'] = temp_pgpass.name
except UnicodeEncodeError:
# If the current locale can't encode the data, we let
# the user input the password manually.
pass
subprocess.check_call(args)
finally:
if temp_pgpass:
temp_pgpass.close()
if 'PGPASSFILE' in os.environ: # unit tests need cleanup
del os.environ['PGPASSFILE']
def _parse_comp(self, comp, y_offset):
last_y_offset = self.y_offset
self.y_offset = y_offset
self.position_y = y_offset
for child in comp:
if self.position_y > (self.height + self.bottom_h):
self.add_page()
current_x = self.l_margin + get_size(child, 'left')
current_y = self.get_top_component(child)
current_w = get_size(child, 'width')
current_h = get_size(child, 'height')
mtd = 'parse_' + child.tag.lower()
if hasattr(self, mtd):
fct = getattr(self, mtd)
# six.print_("print: %s (x=%f,y=%f,w=%f,h=%f) " % (child.tag, current_x / mm, current_y / mm, current_w / mm, current_h / mm))
fct(child, current_x, current_y, current_w, current_h)
else:
six.print_("Unsupported method: " + mtd)
self.y_offset = last_y_offset
def test_scheduler(self):
six.print_('-- Begin test_scheduler --')
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_grid_equal('tasks', {"name": "nom", "trigger": "déclencheur", "nextdate": "date suivante"}, 0)
self.calljson('/lucterios.dummy/addSchedulerTask', {})
self.assert_observer('core.acknowledge', 'lucterios.dummy', 'addSchedulerTask')
value = Params.getvalue('dummy-value')
self.assertEqual(value, "")
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_count_equal('tasks', 1)
self.assert_json_equal('', 'tasks/@0/name', 'Run simple action')
self.assert_json_equal('', 'tasks/@0/trigger', 'interval[0:00:10]')
self.assert_json_equal('', 'tasks/@0/nextdate', datetime.now().strftime('%Y-%m-%d %H:'), True)
sleep(6 * 10 + .2)
value = Params.getvalue('dummy-value')
self.assertEqual(len(value.split('{[br/]}')), 5)
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_count_equal('tasks', 1)
self.assert_json_equal('', 'tasks/@0/name', 'Run simple action')
self.assert_json_equal('', 'tasks/@0/trigger', 'date[' + datetime.now().strftime('%Y-%m-%d %H:'), True)
self.assert_json_equal('', 'tasks/@0/nextdate', datetime.now().strftime('%Y-%m-%d %H:'), True)
sleep(10 + .2)
value = Params.getvalue('dummy-value')
self.assertEqual(value, "")
self.factory.xfer = SessionList()
self.calljson('/CORE/sessionList', {}, False)
self.assert_observer('core.custom', 'CORE', 'sessionList')
self.assert_count_equal('tasks', 0)
six.print_('-- End test_scheduler --')
def _parse_comp(self, comp, y_offset):
last_y_offset = self.y_offset
self.y_offset = y_offset
self.position_y = y_offset
for child in comp:
if self.position_y > (self.height + self.bottom_h):
self.add_page()
current_x = self.l_margin + get_size(child, 'left')
current_y = self.get_top_component(child)
current_w = get_size(child, 'width')
current_h = get_size(child, 'height')
mtd = 'parse_' + child.tag.lower()
if hasattr(self, mtd):
fct = getattr(self, mtd)
# six.print_("print: %s (x=%f,y=%f,w=%f,h=%f) " % (child.tag, current_x / mm, current_y / mm, current_w / mm, current_h / mm))
fct(child, current_x, current_y, current_w, current_h)
else:
six.print_("Unsupported method: " + mtd)
self.y_offset = last_y_offset
def _create_test_db(self, verbosity=1, autoclobber=False, keepdb=False):
"""
Create the test databases using a connection to database 'master'.
"""
if self._test_database_create(settings):
try:
with use_master_connection(self):
test_database_name = super(DatabaseCreation, self)._create_test_db(verbosity, autoclobber)
except Exception as e:
if 'Choose a different database name.' in str(e):
six.print_('Database "%s" could not be created because it already exists.' % test_database_name)
else:
six.reraise(*sys.exc_info())
self.install_regex_clr(test_database_name)
return test_database_name
if verbosity >= 1:
six.print_("Skipping Test DB creation")
return self._get_test_db_name()
def assert_select_equal(self, path, selects, checked=None):
if checked is None:
tag = 'SELECT'
else:
tag = 'CHECKLIST'
self.assertTrue(self.response_json is not None)
self.assertTrue(self.response_xml is None)
self.assertEqual(self.json_comp[path]['component'], tag)
if isinstance(selects, dict):
self.assertEqual(len(self.json_comp[path]['case']), len(selects))
try:
for case in self.json_comp[path]['case']:
vid = case[0]
self.assertEqual(selects[vid], case[1])
except Exception:
six.print_(self.json_comp[path]['case'])
raise
else:
self.assertEqual(len(self.json_comp[path]['case']), selects)
def assert_select_equal(self, path, selects, checked=None):
if checked is None:
tag = 'SELECT'
else:
tag = 'CHECKLIST'
self.assertTrue(self.response_json is not None)
self.assertTrue(self.response_xml is None)
self.assertEqual(self.json_comp[path]['component'], tag)
if isinstance(selects, dict):
self.assertEqual(len(self.json_comp[path]['case']), len(selects))
try:
for case in self.json_comp[path]['case']:
vid = case[0]
self.assertEqual(selects[vid], case[1])
except Exception:
six.print_(self.json_comp[path]['case'])
raise
else:
self.assertEqual(len(self.json_comp[path]['case']), selects)
def fillresponse(self):
if "SAVE" in self.params.keys():
del self.params["SAVE"]
if self.has_changed:
self.item.editor.before_save(self)
try:
self.item.save()
self.has_changed = False
if self.fill_manytomany_fields():
self.item.save()
except IntegrityError as err:
getLogger("lucterios.core.container").info("%s", err)
six.print_(err)
self.raise_except(
_("This record exists yet!"), self.raise_except_class)
if self.except_msg == '':
self.item.editor.saving(self)
if isinstance(self.redirect_to_show, six.text_type):
self.redirect_action(ActionsManage.get_act_changed(
self.model.__name__, self.redirect_to_show, '', ''), {'params': {self.field_id: self.item.id}})
def run_new_migration(self, tmp_path):
from inspect import getmembers, isfunction
from django.apps import apps
from django.db import DEFAULT_DB_ALIAS, connections
from django.db.migrations.executor import MigrationExecutor
connection = connections[DEFAULT_DB_ALIAS]
connection.prepare_database()
executor = MigrationExecutor(connection)
for target in self.get_other_targets(tmp_path, executor):
try:
target_conf = apps.get_app_config(target[0])
migrat_mod = import_module(
"%s.migrations.%s" % (target_conf.module.__name__, target[1]))
for migr_obj in getmembers(migrat_mod):
if isfunction(migr_obj[1]) and (migr_obj[0][0] != '_'):
six.print_("run %s.%s.%s" %
(target[0], target[1], migr_obj[0]))
migr_obj[1]()
except Exception:
pass
def _time(val, default=None):
if not val:
val = ''
# Handle the special case of '24:00'
if val[:2] == '24':
val = '23:59'
ret = None
try:
ret = dateparse.parse_time(val)
except ValueError as e:
print_('Bad time string: {}'.format(val), file=sys.stderr)
six.reraise(ValueError, e)
if isinstance(ret, datetime.time):
return ret
if default is not None:
return _time(default)
return None
def run_new_migration(self, tmp_path):
from inspect import getmembers, isfunction
from django.apps import apps
from django.db import DEFAULT_DB_ALIAS, connections
from django.db.migrations.executor import MigrationExecutor
connection = connections[DEFAULT_DB_ALIAS]
connection.prepare_database()
executor = MigrationExecutor(connection)
for target in self.get_other_targets(tmp_path, executor):
try:
target_conf = apps.get_app_config(target[0])
migrat_mod = import_module(
"%s.migrations.%s" %
(target_conf.module.__name__, target[1]))
for migr_obj in getmembers(migrat_mod):
if isfunction(migr_obj[1]) and (migr_obj[0][0] != '_'):
six.print_("run %s.%s.%s" %
(target[0], target[1], migr_obj[0]))
migr_obj[1]()
except Exception:
pass
def assert_observer(self, obsname, extension, action):
self.assertTrue(self.response_json is not None)
self.assertTrue(self.response_xml is None)
try:
self.assertEquals(
self.json_meta['observer'], obsname,
self.response_json['exception']['message']
if self.json_meta['observer'] == 'core.exception' else None)
self.assertEquals(self.json_meta['extension'], extension)
self.assertEquals(self.json_meta['action'], action)
if self.json_meta['observer'] == 'core.custom':
comp_coord = {}
for comp_name, comp in self.json_comp.items():
ident = (comp['tab'], comp['x'], comp['y'])
comp_coord.setdefault(ident, []).append(comp_name)
self.assertListEqual(
[(names, ident)
for ident, names in comp_coord.items() if len(names) > 1],
[], 'components have same coordonates')
except AssertionError:
if self.json_meta['observer'] == 'core.exception':
six.print_("Error:" +
self.response_json['exception']['message'])
six.print_("Call-stack:" + self.response_json['exception']
['debug'].replace("{[br/]}", "\n"))
if self.json_meta['observer'] == 'core.dialogbox':
six.print_("Message:" + self.json_data['text'])
raise
def _destroy_test_db(self, test_database_name, verbosity=1):
"""
Drop the test databases using a connection to database 'master'.
"""
if not self._test_database_create(settings):
if verbosity >= 1:
six.print_("Skipping Test DB destruction")
return
for alias in connections:
connections[alias].close()
try:
with self.connection.cursor() as cursor:
qn_db_name = self.connection.ops.quote_name(test_database_name)
# boot all other connections to the database, leaving only this connection
cursor.execute("ALTER DATABASE %s SET SINGLE_USER WITH ROLLBACK IMMEDIATE" % qn_db_name)
time.sleep(1)
# after we switch to master, database is clear to drop
cursor.execute("USE [master]")
cursor.execute("DROP DATABASE %s" % qn_db_name)
except Exception:
six.reraise(*sys.exc_info())
def _create_test_db(self, verbosity=1, autoclobber=False, keepdb=False):
"""
Create the test databases using a connection to database 'master'.
"""
if self._test_database_create(settings):
try:
test_database_name = super(DatabaseCreation,
self)._create_test_db(
verbosity, autoclobber)
except Exception as e:
if 'Choose a different database name.' in str(e):
six.print_(
'Database "%s" could not be created because it already exists.'
% test_database_name)
else:
six.reraise(*sys.exc_info())
self.install_regex_clr(test_database_name)
return test_database_name
if verbosity >= 1:
six.print_("Skipping Test DB creation")
return self._get_test_db_name()
def get_actions(cls, ident, xfer, model_name=None, key=None, **args):
cls._actlock.acquire()
try:
acts = []
if model_name is None:
model_name = xfer.model.get_long_name()
if model_name in cls._ACTION_LIST.keys():
for act_ident, act_xclass, act_title, act_icon, act_condition, act_options in cls._ACTION_LIST[model_name]:
try:
if (act_ident == ident) and ((act_condition is None) or act_condition(xfer, **args)):
acts.append((act_xclass.get_action(act_title, act_icon), dict(act_options)))
except Exception:
six.print_('error for [%s,%s,%s,%s]' % (act_ident, act_xclass, act_title, act_icon))
raise
if key is not None:
acts.sort(key=key)
for act in acts:
for remove_opt in ['intop', 'model_name']:
if remove_opt in act[1]:
del act[1][remove_opt]
return acts
finally:
cls._actlock.release()
def fillresponse(self):
if "SAVE" in self.params.keys():
del self.params["SAVE"]
if self.has_changed:
self.item.editor.before_save(self)
try:
self.item.save()
self.has_changed = False
if self.fill_manytomany_fields():
self.item.save()
except IntegrityError as err:
getLogger("lucterios.core.container").info("%s", err)
six.print_(err)
self.raise_except(
_("This record exists yet!"), self.raise_except_class)
if self.except_msg == '':
self.item.editor.saving(self)
if self.getparam('URL_TO_REDIRECT') is not None:
url_text = self.getparam('URL_TO_REDIRECT')
self.redirect_action(WrapAction('', '', url_text=url_text), params={self.field_id: self.item.id})
elif isinstance(self.redirect_to_show, six.text_type):
self.redirect_action(ActionsManage.get_action_url(self.model.get_long_name(), self.redirect_to_show, self),
params={self.field_id: self.item.id})
def correct_db_field(fields):
def check_ret(val):
if isinstance(val, int):
return val
elif hasattr(val, "rowcount"):
return val.rowcount
return 0
from django.db import connection
if connection.vendor == 'sqlite':
query = "UPDATE %s SET %s=0 WHERE typeof(%s)='text'"
else:
query = "UPDATE %s SET %s=0 WHERE %s='NaN'"
ret = 0
try:
with connection.cursor() as cursor:
for tablename, fieldname in fields.items():
ret += check_ret(
cursor.execute(query % (tablename, fieldname, fieldname)))
except Exception:
logging.getLogger('lucterios.framwork').exception("correct_db_field")
if ret > 0:
six.print_("%s DB corrections" % ret)
def importsql(self, sql_file_path):
create_script, insert_script = self.read_sqlfile(sql_file_path)
cur = self.open()
try:
for item_script in create_script:
try:
cur.execute(item_script)
except (sqlite3.IntegrityError, sqlite3.OperationalError):
six.print_('error: %s', item_script)
raise
last_begin = ""
for item_script in insert_script:
try:
if last_begin != item_script[:70]:
self.con.commit()
last_begin = item_script[:70]
cur.execute(item_script)
except (sqlite3.IntegrityError, sqlite3.OperationalError):
six.print_('error: %s', item_script)
raise
finally:
self.con.commit()
self.close()
def assert_observer(self, obsname, extension, action):
self.assertTrue(self.response_json is not None)
self.assertTrue(self.response_xml is None)
try:
self.assertEquals(self.json_meta['observer'], obsname, self.response_json['exception']['message'] if self.json_meta['observer'] == 'core.exception' else None)
self.assertEquals(self.json_meta['extension'], extension)
self.assertEquals(self.json_meta['action'], action)
except AssertionError:
if self.json_meta['observer'] == 'core.exception':
six.print_("Error:" + self.response_json['exception']['message'])
six.print_("Call-stack:" + self.response_json['exception']['debug'].replace("{[br/]}", "\n"))
if self.json_meta['observer'] == 'core.dialogbox':
six.print_("Message:" + self.json_data['text'])
raise
def assert_observer(self, obsname, extension, action):
try:
self.assert_attrib_equal('', 'observer', obsname)
self.assert_attrib_equal('', 'source_extension', extension)
self.assert_attrib_equal('', 'source_action', action)
except AssertionError:
if self.get_first_xpath('').get('observer') == 'core.exception':
six.print_(
"Error:" + six.text_type(self.get_first_xpath('EXCEPTION/MESSAGE').text))
six.print_("Call-stack:" + six.text_type(
self.get_first_xpath('EXCEPTION/DEBUG_INFO').text).replace("{[br/]}", "\n"))
if self.get_first_xpath('').get('observer') == 'core.dialogbox':
six.print_(
"Message:" + six.text_type(self.get_first_xpath('TEXT').text))
raise
def assert_observer(self, obsname, extension, action):
self.assertTrue(self.response_json is not None)
self.assertTrue(self.response_xml is None)
try:
self.assertEquals(
self.json_meta['observer'], obsname,
self.response_json['exception']['message']
if self.json_meta['observer'] == 'core.exception' else None)
self.assertEquals(self.json_meta['extension'], extension)
self.assertEquals(self.json_meta['action'], action)
except AssertionError:
if self.json_meta['observer'] == 'core.exception':
six.print_("Error:" +
self.response_json['exception']['message'])
six.print_("Call-stack:" + self.response_json['exception']
['debug'].replace("{[br/]}", "\n"))
if self.json_meta['observer'] == 'core.dialogbox':
six.print_("Message:" + self.json_data['text'])
raise
def show_info_(self):
for msg_item in self.msg_list:
six.print_(msg_item)
def print_xml(self, xpath):
xml_value = self.get_first_xpath(xpath)
six.print_(etree.tostring(
xml_value, xml_declaration=True, pretty_print=True, encoding='utf-8').decode("utf-8"))
def main():
six.print_(test_inbound_payload['html'])
def show_info_(self):
for msg_item in self.msg_list:
six.print_(msg_item)
def print_json(self, path=None):
if path is None:
path = self.response_json
elif isinstance(path, six.text_type):
path = self.get_json_path(path)
six.print_(self._get_json_dump(path))
def _log(s, verbosity, priority):
if priority <= verbosity:
print_(s)
def fill_content(self, request):
ReportModelGenerator.fill_content(self, request)
self.horizontal_marge = self.label_size['left_marge']
self.vertical_marge = self.label_size['top_marge']
self.page_width = self.label_size['page_width']
self.page_height = self.label_size['page_height']
label_values = []
for _ in range(1, self.first_label):
label_values.append("")
for item in self.get_items_filtered():
item.set_context(self.xfer)
label_values.append(item.evaluate(self.label_text))
index = 0
for labelval in label_values:
if index == (self.label_size['columns'] * self.label_size['rows']):
index = 0
self.add_page()
col_num = index % self.label_size['columns']
row_num = int(index / self.label_size['columns'])
left = col_num * self.label_size['horizontal_space']
top = row_num * self.label_size['vertical_space']
if self.mode == 0:
xml_text = convert_to_html('text', labelval, "sans-serif", 9,
10, "center")
xml_text.attrib[
'height'] = "%d.0" % self.label_size['cell_height']
xml_text.attrib[
'width'] = "%d.0" % self.label_size['cell_width']
xml_text.attrib['top'] = "%d.0" % top
xml_text.attrib['left'] = "%d.0" % left
xml_text.attrib['spacing'] = "0.0"
self.body.append(xml_text)
else:
try:
docroot = etree.XML(labelval)
except etree.XMLSyntaxError:
six.print_(labelval)
raise
for xml_text in docroot.find('body').iter():
if xml_text.tag == 'body':
continue
if xml_text.tag == 'text':
new_xml_text = convert_text_xml(xml_text)
else:
new_xml_text = xml_text
if 'top' in xml_text.attrib:
top_offset = float(top) + float(xml_text.attrib['top'])
else:
top_offset = float(top)
if 'left' in xml_text.attrib:
left_offset = float(left) + float(
xml_text.attrib['left'])
else:
left_offset = float(left)
if 'width' in xml_text.attrib:
width = float(xml_text.attrib['width'])
else:
width = self.label_size['cell_width']
if 'height' in xml_text.attrib:
height = float(xml_text.attrib['height'])
else:
height = self.label_size['cell_height']
new_xml_text.attrib['top'] = "%.1f" % top_offset
new_xml_text.attrib['left'] = "%.1f" % left_offset
new_xml_text.attrib['width'] = "%.1f" % width
new_xml_text.attrib['height'] = "%.1f" % height
new_xml_text.attrib['spacing'] = "0.0"
self.body.append(new_xml_text)
index += 1
