def create_procedures(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/' %
(username, password, host, port, database))
Procedure = Model.get('galeno.procedure')
to_save = []
cont = 0
with open(filename, 'rb') as procedure_file:
fieldnames = ['code', 'name']
reader = csv.DictReader(procedure_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
cont += 1
print((cont, row))
procedure = Procedure()
for field in row:
if row[field] == '':
value = None
else:
value = row[field]
setattr(procedure, field, value)
procedure.core = True
to_save.append(procedure)
Procedure.save(to_save)
def create_groups(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/' %
(username, password, host, port, database))
Group = Model.get('galeno.disease.group')
groups = Group.find([])
with open(filename, 'wb') as group_file:
fieldnames = ['code', 'name', 'description', 'information']
writer = csv.DictWriter(group_file,
delimiter=';',
fieldnames=fieldnames)
writer.writeheader()
for group in groups:
if group.description:
description = group.description.encode('utf-8')
else:
description = None
if group.information:
information = group.information.encode('utf-8')
else:
information = None
writer.writerow({
'code': group.code.encode('utf-8'),
'name': group.name.encode('utf-8'),
'description': description,
'information': information,
})
def connect(pconfig):
# get access to tryton database for processing state updates
# use http only on local test instance (and uncomment [ssl] entries in
# server side trytond.conf for using http)
config.set_xmlrpc("http://" + pconfig["user"] + ":" + pconfig["password"] +
"@" + pconfig["host"] + ":" + pconfig["port"] + "/" +
pconfig["database"])
def get_tryton_connection():
tryton = settings['tryton']
try:
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
return pconfig.set_xmlrpc(tryton['server'], context=ssl_context)
except AttributeError:
# If python is older than 2.7.9 it doesn't have
# ssl.create_default_context() but it neither verify certificates
return pconfig.set_xmlrpc(tryton['server'])
def create_diseases(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/' %
(username, password, host, port, database))
Disease = Model.get('galeno.disease')
diseases = Disease.find([])
with open(filename, 'wb') as disease_file:
fieldnames = [
'code', 'name', 'category', 'groups', 'chromosome', 'protein',
'gene', 'information', 'active'
]
writer = csv.DictWriter(disease_file,
delimiter=';',
fieldnames=fieldnames)
writer.writeheader()
for disease in diseases:
print(disease)
groups = None
for group in disease.groups:
if groups is None:
groups = ""
else:
groups += ','
groups += group.code.encode('utf-8')
writer.writerow({
'code':
disease.code.encode('utf-8'),
'name':
disease.name.encode('utf-8'),
'category':
disease.category.id,
'gene':
disease.gene and disease.gene.encode('utf-8') or None,
'groups':
groups,
'information':
disease.information and disease.information.encode('utf-8')
or None,
'chromosome':
disease.chromosome and disease.chromosome.encode('utf-8')
or None,
'protein':
disease.protein and disease.protein.encode('utf-8') or None,
'active':
disease.active,
})
def _init_xmlrpc_connection(self,
host,
user,
password,
database='tryton',
ssl_context=None,
port=8000,
**kwargs):
proteus_config.set_xmlrpc(
url='http://{user}:{password}@{host}:{port}/{database}/'.format(
user=quote(user),
password=quote(password),
host=host,
port=int(port),
database=quote(database)),
context=ssl_context)
def get_tryton_connection():
if 'TRYTOND_TESTER_URI' in os.environ:
url = os.environ['TRYTOND_TESTER_URI']
else:
tryton = settings['tryton']
url = tryton['server']
try:
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
return pconfig.set_xmlrpc(url, context=ssl_context)
except AttributeError:
# If python is older than 2.7.9 it doesn't have
# ssl.create_default_context() but it neither verify certificates
return pconfig.set_xmlrpc(url)
def create_diseases(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/' %
(username, password, host, port, database))
Disease = Model.get('galeno.disease')
Group = Model.get('galeno.disease.group')
Category = Model.get('galeno.disease.category')
to_save = []
with open(filename, 'rb') as disease_file:
fieldnames = [
'code', 'name', 'category', 'groups', 'chromosome', 'protein',
'gene', 'information', 'active'
]
reader = csv.DictReader(disease_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
print(row)
disease = Disease()
for field in row:
if row[field] == '':
value = None
else:
if field == 'active':
value = bool(row[field])
elif field == 'category':
category, = Category.find([('code', '=', row[field])])
value = category
elif field == 'groups':
value = []
for group_code in row[field].split(','):
group, = Group.find([('code', '=', group_code)])
value.append(group)
else:
value = row[field]
if field != 'groups':
setattr(disease, field, value)
else:
if value:
for group in value:
disease.groups.append(group)
disease.core = True
to_save.append(disease)
Disease.save(to_save)
def translate_categories(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/'
% (username, password, host, port, database))
Category = Model.get('galeno.disease.category')
to_save = []
with open(filename, 'rb') as category_file:
fieldnames = ['code', 'name', 'parent']
reader = csv.DictReader(
category_file, delimiter=';', fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
category, = Category.find([('code', '=', row['code'])])
category.name = row['name']
to_save.append(category)
Category.save(to_save)
def translate_groups(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/'
% (username, password, host, port, database))
Group = Model.get('galeno.disease.group')
to_save = []
with open(filename, 'rb') as group_file:
fieldnames = ['code', 'name', 'parent']
reader = csv.DictReader(
group_file, delimiter=';', fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
group, = Group.find([('code', '=', row['code'])])
group.name = row['name']
to_save.append(group)
Group.save(to_save)
def create_categories(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/'
% (username, password, host, port, database))
Category = Model.get('galeno.disease.category')
categories = Category.find([])
with open(filename, 'wb') as category_file:
fieldnames = ['code', 'name', 'parent']
writer = csv.DictWriter(
category_file, delimiter=';', fieldnames=fieldnames)
writer.writeheader()
for category in categories:
writer.writerow({
'name': category.name.encode('utf-8'),
'parent': category.parent and category.parent.id or None,
'code': category.id
})
def create_groups(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/' %
(username, password, host, port, database))
Group = Model.get('galeno.disease.group')
with open(filename, 'rb') as group_file:
fieldnames = ['code', 'name', 'description', 'information']
reader = csv.DictReader(group_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
group = Group()
for field in row:
if row[field] == '':
value = None
else:
value = row[field]
setattr(group, field, value)
group.core = True
group.save()
def translate_diseases(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/' %
(username, password, host, port, database))
Disease = Model.get('galeno.disease')
to_save = []
with open(filename, 'rb') as disease_file:
fieldnames = [
'code', 'name', 'category', 'groups', 'chromosome', 'protein',
'gene', 'information', 'active'
]
reader = csv.DictReader(disease_file,
delimiter=';',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
print(row)
disease, = Disease.find([('code', '=', row['code'])])
disease.name = row['name']
to_save.append(disease)
Disease.save(to_save)
def create_categories(host, port, database, username, password, filename):
pdb.set_trace()
config.set_xmlrpc('http://%s:%s@%s:%s/%s/' %
(username, password, host, port, database))
Category = Model.get('galeno.disease.category')
with open(filename, 'rb') as category_file:
fieldnames = ['code', 'name', 'parent']
reader = csv.DictReader(category_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
if row['parent'] != '':
parent, = Category.find([('code', '=', row['parent'])])
else:
parent = None
category = Category()
category.code = row['code']
category.name = row['name']
category.parent = parent
category.core = True
category.save()
attendee.value = 'MAILTO:%s' % email
attendees.append(attendee)
vevent.attendee_list = attendees
caldav.Event(self.client, data=ical.serialize(),
parent=self.calendar).save()
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument('--xmlrpc',
dest='xmlrpc',
metavar='URL',
help='use trytond XML-RPC at URL')
parser.add_argument('--url',
dest='url',
metavar='URL',
help='use calendar at URL')
options = parser.parse_args()
config = config.set_xmlrpc(options.xmlrpc)
xmlrpc_user = urlparse(options.xmlrpc).username
user = urlparse(options.url).username
assert xmlrpc_user == user
assert user != 'foo'
install_module('calendar_scheduling', config)
configure_user(user, config)
configure_user('foo', config)
create_calendar(user, user, config)
create_calendar('foo', user, config)
URL = options.url
unittest.main(argv=sys.argv[:1])
break
event.instance.vevent.attendee_list = []
event.save()
Event = Model.get('calendar.event')
self.assertEqual(Event.find([
('calendar.owner.email', '=', '*****@*****.**'),
]), [])
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('--xmlrpc', dest='xmlrpc', metavar='URL',
help='use trytond XML-RPC at URL')
parser.add_option('--url', dest='url', metavar='URL',
help='use calendar at URL')
(options, args) = parser.parse_args()
config = config.set_xmlrpc(options.xmlrpc)
xmlrpc_user = urlparse(options.xmlrpc).username
user = urlparse(options.url).username
assert xmlrpc_user == user
assert user != 'foo'
install_module('calendar', config)
configure_user(user, config)
configure_user('foo', config)
configure_user('bar', config)
create_calendar(user, user, config)
create_calendar('foo', user, config)
create_calendar('bar', user, config)
URL = options.url
unittest.main(argv=sys.argv[:1])
def federation_queue(action):
Queue = Model.get('gnuhealth.federation.queue')
mqueued = Queue.find([('state', '=', 'queued')])
queued_messages = len(mqueued)
print("Number of messages in the queue", queued_messages)
if (action == "check"):
exit(0)
if (action == "push"):
print("Sending messages with status Queued...")
for msg in mqueued:
print(msg.msgid, msg.federation_locator, msg.time_stamp, msg.model,
msg.node)
try:
msg.click('send')
except:
print("Failed to send message ", msg.msgid)
if (len(sys.argv) < 2):
exit(usage)
print("Connecting to GNU Health Server ...")
conf = config.set_xmlrpc(health_server)
print("Connected !")
federation_queue(action=sys.argv[1])
#!/usr/bin/python
from proteus import config, Model, Wizard
config = config.set_xmlrpc('http://*****:*****@localhost:8069/test')
Sale = Model.get('sale.sale')
sales = Sale.find()
for s in sales:
print s.id, s.party.name, s.description, s.state, s.invoice_state, s.write_date, s.create_date
Procedure,
Practitioner,
Observation,
DiagnosticReport,
Immunization,
FamilyMemberHistory,
MedicationStatement,
Encounter,
ClinicalImpression,
Coverage,
)
from proteus import config, Model
import pytest
config = config.set_xmlrpc(
"http://*****:*****@federation.gnuhealth.org:8000/health36/"
)
# @pytest.mark.skip
def test_ci_info():
CI = Model.get("gnuhealth.patient.evaluation")
for ci in CI.find():
info = ClinicalImpression.to_fhir_object(ci)
# @pytest.mark.skip
def test_enc_info():
ENC = Model.get("gnuhealth.patient.evaluation")
for enc in ENC.find():
info = Encounter.to_fhir_object(enc)
PROTEUS_CONFIG = dict(CONFIGURATION.items('proteus'))
except ConfigParser.NoSectionError:
print "Error: Please run repro.py from the c3sRepertoireProcessing folder."
exit()
FILEHANDLING_CONFIG = dict(CONFIGURATION.items('filehandling'))
if not FILEHANDLING_CONFIG['echoprint_server_token']:
FILEHANDLING_CONFIG['echoprint_server_token'] = os.environ.get(
'ECHOPRINT_SERVER_TOKEN', None
)
HOSTNAME = socket.gethostname()
STORAGE_BASE_PATH = FILEHANDLING_CONFIG['storage_base_path']
# get access to database
config.set_xmlrpc(
"https://" + PROTEUS_CONFIG['user'] + ":" + PROTEUS_CONFIG['password'] + "@"
+ PROTEUS_CONFIG['host'] + ":" + PROTEUS_CONFIG['port'] + "/" + PROTEUS_CONFIG['database']
)
#--- Processing stage functions for single audiofiles ---
def preview_audiofile(srcdir, destdir, filename):
"""
Creates a low-quality preview audio snippet for newly uploaded files.
"""
# make sure previews and excerpts paths exist
content_base_path = FILEHANDLING_CONFIG['content_base_path']
if ensure_path_exists(content_base_path) is None:
print "ERROR: '" + content_base_path + "' couldn't be created as content base path."
settings.lang = option.lang
settings.url = option.url
settings.path = option.path
else:
print usage
return settings
if __name__ == "__main__":
settings = parse_arguments(sys.argv[1:])
if settings.database:
config.set_trytond(database=settings.database)
else:
config.set_xmlrpc(settings.url)
Module = Model.get('ir.module.module')
if settings.module == 'all':
modules = Module.find([('state', '=', 'installed')])
else:
modules = Module.find([
('state', '=', 'installed'),
('name', '=', settings.module),
])
Lang = Model.get('ir.lang')
language, = Lang.find([('code', '=', settings.lang)])
for module in modules:
path = settings.path if settings.path else ''
good = False
bad_patient.append(('error', i, e))
if good:
notification = make_notification(row, patient)
try:
patient.name.save()
patient.save()
notification.save()
notifications.append(notification)
good_notify.append(i)
except Exception, e:
bad_notify.append(('error', i, e, notification))
results = {'badn': bad_notify, 'badppl': bad_patient, 'skipped': skipped,
'goodn': good_notify, 'notifications': notifications}
return results
if __name__ == '__main__':
filename = sys.argv[1]
tryton_conf = sys.argv[2]
if tryton_conf.startswith('http'):
pconfig.set_xmlrpc(tryton_conf)
if len(sys.argv) > 1:
outfile = sys.argv[2]
else:
outfile = '{}.pypickle'.format(filename[:filename.rindex('.')])
outdata = process_xlfile(filename)
pickle.dump(outdata, open(outfile, 'wt'))
def set_client(parameters):
from proteus import config
config.set_xmlrpc(arguments.tryton_url)
