def init_base():
init_logging()
mainlog.setLevel(logging.INFO)
load_configuration("server.cfg")
parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
description='This is an Horse! migration script.',
epilog="For example --db-url {}".format(
configuration.get("Database", "admin_url")))
parser.add_argument('--db-url', default=configuration.database_url, help='Database URL')
args = parser.parse_args()
mainlog.info("Connecting to {}".format(args.db_url))
init_i18n()
from koi.db_mapping import metadata
init_db_session(args.db_url, metadata, False) # True or configuration.echo_query)
def _save(self):
try:
old_server_ip = configuration.get("DEFAULT", "public_ip")
cfg_path = os.path.join(get_data_dir(), "server.cfg")
f = open(cfg_path, "w")
f.write(self.text_edit_widget.toPlainText())
f.close()
self._log._log_success(
"Server configuration saved in {}".format(cfg_path))
load_configuration(cfg_path, "server_config_check.cfg")
self._log._log_success("Server configuration reloaded")
server_ip = configuration.get("DEFAULT", "public_ip")
if old_server_ip != server_ip:
self._log._log_success(
"Updating IP address in the downloadable delivery_slips")
inject_public_ip_in_client(server_ip)
except Exception as ex:
self._log._log_error(
"Something went wrong while saving the configuration : {}".
format(ex))
self._log._log("Reloading server configuration")
import threading
def open_server(url):
try:
urlopen(url)
except ConnectionResetError as ex:
pass
threading.Thread(target=open_server,
args=['http://127.0.0.1:8079/reload']).start()
from datetime import date
import argparse
from sqlalchemy.sql import select, func, and_, or_
from koi.base_logging import mainlog, init_logging
from koi.Configurator import init_i18n, load_configuration, configuration, resource_dir
init_logging()
init_i18n()
load_configuration()
from koi.db_mapping import metadata
from koi.datalayer.database_session import init_db_session, db_engine, session
from koi.datalayer.supplier_mapping import Supplier
from koi.datalayer.supply_order_mapping import SupplyOrderPart, SupplyOrder
import argparse
parser = argparse.ArgumentParser(
description='This is an Horse! migration script.')
parser.add_argument('--db-url',
default=configuration.database_url,
help='Database connection URL {}'.format(
configuration.database_url))
def alter_structure():
try:
session().connection().execute("drop table horse.supplier_orders")
session().commit()
import os.path
from datetime import date
import argparse
from sqlalchemy.sql import select, func, and_, or_
from koi.base_logging import mainlog, init_logging
from koi.Configurator import init_i18n, load_configuration, configuration, resource_dir
init_logging()
init_i18n()
load_configuration("server.cfg")
from koi.db_mapping import metadata
from koi.datalayer.database_session import init_db_session, db_engine, session
from koi.people_admin.people_admin_mapping import *
parser = argparse.ArgumentParser(
description='This is an Horse! migration script.')
parser.add_argument('--db-url',
default=configuration.database_url,
help='Database connection URL {}'.format(
configuration.get("Database", "admin_url")))
from sqlalchemy import create_engine
from sqlalchemy.schema import CreateTable
def dump(sql, *multiparams, **params):
print(sql.compile(dialect=engine.dialect))
def dirup(path):
return os.path.split(os.path.abspath(path))[0]
updir = dirup(dirup(__file__))
# sys.path.append(updir)
# sys.path.append(os.path.join(updir,'server'))
# sys.path.append(os.path.join(updir,'datalayer'))
from koi.Configurator import init_i18n, load_configuration, resource_dir
from koi.base_logging import init_logging
init_logging("test.log")
init_i18n()
# load_configuration(os.path.join( resource_dir,'test_config.cfg'))
load_configuration('config.cfg')
# load_configuration() # Default run on my PC
from koi.Configurator import mainlog, configuration
import koi.db_mapping
from koi.datalayer.database_session import init_db_session, session
init_db_session(configuration.database_url, koi.db_mapping.metadata, True
or configuration.echo_query)
from koi.db_mapping import *
from koi.dao import *
if __name__ == "__main__":
from koi.base_logging import init_logging
from koi.Configurator import init_i18n,load_configuration,configuration
init_logging()
init_i18n()
load_configuration("server.cfg","server_config_check.cfg")
import os.path
from koi.Configurator import resource_dir
from koi.base_logging import mainlog
from koi.doc_manager.client_utils import upload_template
from koi.server.json_decorator import JsonCallWrapper
from koi.doc_manager.documents_service import DocumentsService
import inspect
def register_horse_template_online(description, fn, ref):
documents_service = JsonCallWrapper( DocumentsService(), JsonCallWrapper.HTTP_MODE)
doc_id = documents_service.reference_to_document_id(ref)
if not doc_id:
doc_id = upload_template(os.path.join(resource_dir, fn))
documents_service.update_template_description(doc_id,description,ref)
else:
mainlog.debug("I didn't add {} with reference {} because it's already there".format(fn,ref))
def register_horse_template_offline(description, full_path, ref):
""" Register a file in the template library, will do it by accessing the
server code directly instead of via HTTP.
# return os.path.split(os.path.abspath(path))[0]
# updir = dirup(dirup(__file__))
# sys.path.append(updir)
# sys.path.append(os.path.join(updir,'server'))
# sys.path.append(os.path.join(updir,'datalayer'))
from koi.Configurator import init_i18n, load_configuration, resource_dir
from koi.base_logging import init_logging, mainlog
init_logging("test.log", hook_exceptions=False)
mainlog.setLevel(logging.DEBUG)
init_i18n()
mainlog.debug(u"Test resource dir is {}".format(resource_dir))
load_configuration(
os.path.abspath(os.path.join(resource_dir, 'test_config.cfg')))
from koi.Configurator import configuration
import koi.db_mapping
from koi.datalayer.database_session import init_db_session, session
init_db_session(configuration.database_url, koi.db_mapping.metadata, False
or configuration.echo_query)
from koi.datalayer.create_database import create_all_tables, do_basic_inserts, drop_all_tables, set_up_database, disconnect_db, create_root_account
from koi.datalayer.utils import _extract_db_params_from_url
def add_user(login, password, fullname, roles):
h = hashlib.md5()
h.update(password.encode('utf-8')) # and you need h.hexdigest()
session().connection().execute(
def handle_request(self):
path = re.sub("\\?.*", "", self.path)
params = urlparse.parse_qs(urlparse.urlparse(self.path).query)
if path == '/version':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(
configuration.get("DownloadSite", "current_version"))
return
elif path == '/file':
f = open(configuration.get("DownloadSite", "client_path"), 'rb')
bytes = f.read()
f.close()
self.send_response(200)
self.send_header('Content-type', 'application/octet-stream')
self.send_header('Content-Length', str(len(bytes)))
self.send_header(
'Content-Disposition', 'attachment; filename={}'.format(
os.path.split(
configuration.get("DownloadSite", "client_path"))[-1]))
self.send_header('Content-Transfer-Encoding', 'binary')
self.end_headers()
self.wfile.write(bytes)
mainlog.info("Served {} with {} bytes".format(
configuration.get("DownloadSite", "client_path"), len(bytes)))
return
elif path == '/database':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(configuration.get("DownloadSite", "db_url"))
return
elif path == '/delivery_slips':
f = open(configuration.get("DownloadSite", "client_path"), 'rb')
bytes = f.read()
f.close()
self.send_response(200)
self.send_header('Content-type', 'application/octet-stream')
self.send_header('Content-Length', str(len(bytes)))
self.end_headers()
self.wfile.write(bytes)
return
elif path == '/logo.png':
f = open(os.path.join(resource_dir, "file_server_logo.png"), 'rb')
bytes = f.read()
f.close()
self.send_response(200)
self.send_header('Content-type', 'image/png')
self.end_headers()
self.wfile.write(bytes)
return
elif self.path.startswith('/upgrade'):
if 'version' not in params:
mainlog.error("Upgrade requested without version")
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write("Version parameter not supplied")
return
version = ''.join(params['version']).strip()
mainlog.info("Upgrade requested to version {}".format(version))
res = "No message"
try:
res = upgrade(version)
self.send_response(200)
except Exception as ex:
mainlog.error("Upgrade failed because {}".format(str(ex)))
res = str(ex)
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgi.escape(res))
return
else:
mainlog.error("Unsupported path {} from {}".format(
self.path, self.client_address))
load_configuration("server.cfg", "server_config_check.cfg")
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write("""<html><head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"><style>
p,h2 {text-align:center; font-family:Verdana; }
table, th, td { border: 1px solid #2900af; border-collapse:collapse; padding:0; margin:0; }
img {background-color:white;}
</style></head>
<body>
<br/>
<p><img koi="logo.png"></p>
<br/>
<table width="100%" height="1"><tr><td></td><tr/></table><br/><br/>
<h2>This is the Horse download site !</h2>
""")
self.wfile.write("<p>The current version is <b>{}</b>.</p>".format(
configuration.get("DownloadSite", "current_version")))
self.wfile.write(
"<p>To download the latest delivery_slips, <a href='/file'>click here</a>.</p>"
)
self.wfile.write("</body></html>")
# return nr_matches,first_match
@Slot(QModelIndex)
def index_changed(ndx):
# print "index_changed {}".format(ndx)
pass
if __name__ == "__main__":
from koi.base_logging import init_logging
from koi.Configurator import init_i18n, load_configuration
init_logging("completer.log")
init_i18n()
load_configuration("config.cfg")
from koi.Configurator import configuration # Why should I do this here ? I don't get it :-(
from koi.datalayer.sqla_mapping_base import metadata
from koi.datalayer.database_session import init_db_session
init_db_session(configuration.database_url, metadata, False
or configuration.echo_query)
from PySide.QtGui import QApplication, QMainWindow, QWidget, QHBoxLayout
from koi.dao import dao
app = QApplication(sys.argv)
window = QMainWindow()
from koi.machine.machine_service import machine_service
