def rangecontraints_DELETE_one(self):
""" Find and delete one rangeconstraint by id with DELETE method """
app_id = self.request.swagger_data['appid']
confkey_id = self.request.swagger_data['ckid']
rc_id = self.request.swagger_data['rcid']
rangeconstraint = RangeConstraint.get(rc_id)
try:
# Checks if ConfigurationKey exists with given Application
if not ConfigurationKey.get(confkey_id).application_id == app_id:
raise Exception('Application with id %s does not have' %
app_id +
' ConfigurationKey with id %s' % confkey_id)
# Checks if given RangeConstraint is owned by ConfigurationKey
elif not rangeconstraint.configurationkey_id == confkey_id:
raise Exception('ConfigurationKey with id %s does not' %
confkey_id +
' have RangeConstraint with id %s' % rc_id)
RangeConstraint.destroy(rangeconstraint)
except Exception as e:
print(e)
print_log(datetime.datetime.now(), 'DELETE',
'/rangeconstraint/' + str(rc_id),
'Delete rangeconstraint', 'Failed')
return self.createResponse(None, 400)
print_log(datetime.datetime.now(), 'DELETE',
'/rangeconstranit/' + str(rc_id), 'Delete rangeconstraint',
'Succeeded')
return {}
def exclusionconstraints_POST(self):
app_id = self.request.swagger_data['appid']
exconstraint = self.request.swagger_data['exclusionconstraint']
new_exconstraint = ExclusionConstraint(
first_configurationkey_id=exconstraint[
'first_configurationkey_id'],
first_operator_id=exconstraint['first_operator_id'],
first_value_a=None if len(exconstraint['first_value']) == 0 else
exconstraint['first_value'][0],
first_value_b=None if len(exconstraint['first_value']) <= 1 else
exconstraint['first_value'][1],
second_configurationkey_id=exconstraint[
'second_configurationkey_id'],
second_operator_id=exconstraint['second_operator_id'],
second_value_a=None if len(exconstraint['second_value']) == 0 else
exconstraint['second_value'][0],
second_value_b=None if len(exconstraint['second_value']) <= 1 else
exconstraint['second_value'][1])
if not self.is_valid_exclusionconstraint(new_exconstraint, app_id):
print_log(
datetime.datetime.now(), 'POST',
'/application/%s/exclusionconstraints' % (app_id),
'Create new exclusionconstraint for configurationkey',
'Failed: ExclusionConstraint is not valid: %s' %
(new_exconstraint.as_dict()))
return self.createResponse({}, 400)
ExclusionConstraint.save(new_exconstraint)
return new_exconstraint.as_dict()
def rangecontraints_POST(self):
""" Create new rangeconstraint for specific configurationkey """
req_rangec = self.request.swagger_data['rangeconstraint']
configkey_id = self.request.swagger_data['ckid']
app_id = self.request.swagger_data['appid']
rconstraint = RangeConstraint(configurationkey_id=configkey_id,
operator_id=req_rangec.operator_id,
value=req_rangec.value)
try:
# Checks if Configuration with such connection to Application exists
if not is_valid_rangeconstraint(app_id, configkey_id, rconstraint):
raise Exception('Application with id %s does not have' %
app_id +
' ConfigurationKey with id %s' % configkey_id)
RangeConstraint.save(rconstraint)
except Exception as e:
print_log(
datetime.datetime.now(), 'POST', '/applications/%s/' % app_id +
'configurationkeys/%s/rangeconstraints' % configkey_id,
'Create new rangeconstraint for configurationkey',
'Failed: %s' % e)
return self.createResponse({}, 400)
print_log(
datetime.datetime.now(), 'POST', '/applications/%s' % app_id +
'/configurationkeys/%s/rangeconstraints' % configkey_id,
'Create new rangeconstraint for configurationkey', 'Succeeded')
return rconstraint.as_dict()
def data_for_app_GET(self):
""" List all configurationkeys and rangeconstraints of specific application.
Returns application with configurationkeys, rangeconstraints and exclusionconstraints
"""
app_id = self.request.swagger_data['id']
app = Application.get(app_id)
if app is None:
print_log(datetime.datetime.now(), 'GET',
'/applications/' + str(id) + '/rangeconstraints',
'Get all things of one application', None)
return self.createResponse(None, 400)
if app.apikey is None:
app = self.set_app_apikey(app, app_id)
configurationkeys = app.configurationkeys
ranges = list(
concat(list(map(lambda _: _.rangeconstraints, configurationkeys))))
exclusions = self.get_app_exclusionconstraints(app_id)
app_data = app.as_dict()
app_data = assoc(app_data, 'configurationkeys',
list(map(lambda _: _.as_dict(), configurationkeys)))
app_data = assoc(app_data, 'rangeconstraints',
list(map(lambda _: _.as_dict(), ranges)))
app_data = assoc(app_data, 'exclusionconstraints',
list(map(lambda _: _.as_dict(), exclusions)))
return app_data
def rangeconstraints_for_configuratinkey_DELETE(self):
"""
Delete all rangeconstraints of one specific configurationkey
To include all the database connection checks which rangecontraints_DELETE_one contains, it is used in this
function.
"""
configkey_id = self.request.swagger_data['ckid']
app_id = self.request.swagger_data['appid']
configurationkey = ConfigurationKey.get(configkey_id)
errors = 0
try:
for rc in configurationkey.rangeconstraints:
# Set rangeconstraint's id, so rangecontraints_DELETE_one can use it
self.request.swagger_data['rcid'] = rc.id
if not self.rangecontraints_DELETE_one() == {}:
errors += 1
except Exception as e:
print(e)
errors += 1
finally:
if (errors > 0):
print_log(
datetime.datetime.now(), 'DELETE',
'/application/%s' % app_id + '/configurationkeys/' +
str(configkey_id) + '/rangeconstraints',
'Delete rangeconstraints of configurationkey', 'Failed')
return self.createResponse(None, 400)
return {}
def configurations_POST(self):
"""
Create new Configuration to ExperimentGroup. Requires Application's id, Experiment's id, ExperimentGroup's id
and Configuration to be created. This will fail if Configuration, or given ids are not valid.
:return: If successfully created, returns created Configuration. If it fails, returns response with HTTP code
400
"""
app_id = self.request.swagger_data['appid']
exp_id = self.request.swagger_data['expid']
expgroup_id = self.request.swagger_data['expgroupid']
req_config = self.request.swagger_data['configuration']
req_config.experimentgroup_id = expgroup_id
if self.is_valid_configuration(app_id, exp_id, expgroup_id,
req_config):
Configuration.save(req_config)
print_log(datetime.datetime.now(), 'POST',
'/applications/%s/experiments/%s/experimentgroups/%s',
'Create Configuration to ExperimentGroup', 'Success')
return req_config.as_dict()
print_log(datetime.datetime.now(), 'POST',
'/applications/%s/experiments/%s/experimentgroups/%s',
'Create Configuration to ExperimentGroup',
'Failed: Invalid Configuration')
return self.createResponse(None, 400)
def client_GET(self):
result = get_client_by_id_and_app(self.request.swagger_data)
if not result:
print_log(datetime.datetime.now(), 'GET','applications/%s/clients/%s' \
% (self.request.swagger_data['appid'], self.request.swagger_data['clientid']),
'Get client', 'Failed')
return self.createResponse(None, 400)
return result.as_dict()
def configurationkeys_GET(self):
""" List all configurationkeys with GET method """
app_id = self.request.swagger_data['id']
if Application.get(app_id) is None:
print_log(datetime.datetime.now(), 'GET', '/applications/%s/configurationkeys'\
% app_id, 'Get configurationkeys', 'Failed')
return self.createResponse(None, 400)
app_conf_keys = ConfigurationKey.query().join(Application).filter(Application.id == app_id)
return list(map(lambda _: _.as_dict(), app_conf_keys))
def get_conf_key_by_appid_and_ckid(app_id, confkey_id):
try:
return ConfigurationKey.query()\
.filter(ConfigurationKey.id == confkey_id)\
.join(Application)\
.filter(Application.id == app_id)\
.one()
except Exception as e:
print_log(e)
return None
def client_DELETE(self):
result = get_client_by_id_and_app(self.request.swagger_data)
if not result:
print_log(datetime.datetime.now(), 'DELETE', '/clients/' + str(id),
'Delete client', 'Failed')
return self.createResponse(None, 400)
Client.destroy(result)
print_log(datetime.datetime.now(), 'DELETE', '/clients/' + str(id),
'Delete client', 'Succeeded')
return {}
def configurationkeys_GET_one(self):
""" Find and return one configurationkey by id with GET method """
app_id = self.request.swagger_data['appid']
confkey_id = self.request.swagger_data['ckid']
confkey = get_conf_key_by_appid_and_ckid(app_id, confkey_id)
if confkey is None:
print_log(datetime.datetime.now(), 'GET',\
'/applications/%s/configurationkeys/' % app_id
+ str(confkey_id), 'Get one configurationkey', 'Failed')
return self.createResponse(None, 400)
return confkey.as_dict()
def experiments_POST(self):
""" Create new experiment """
app_id = self.request.swagger_data['appid']
req_exp = self.request.swagger_data['experiment']
exp = Experiment(name=req_exp.name,
startDatetime=req_exp.startDatetime,
endDatetime=req_exp.endDatetime,
application_id=app_id)
Experiment.save(exp)
print_log(req_exp.name, 'POST', '/experiments',
'Create new experiment', exp)
return exp.as_dict()
def exclusionconstraints_GET_one(self):
""" Find and return one ExclusionConstraint by id with GET method """
app_id = self.request.swagger_data['appid']
exconst_id = self.request.swagger_data['ecid']
exconstraint = self.get_exclusionconstraint(app_id, exconst_id)
if exconstraint is None:
print_log(
datetime.datetime.now(), 'GET',
'/applications/%s/exclusionconstraints/' +
str(exconst_id) % app_id, 'Get one exclusionconstraint',
'Failed')
return self.createResponse(None, 400)
return exconstraint.as_dict()
def configurationkeys_PUT_one(self):
""" Updates only the name of configurationkey"""
app_id = self.request.swagger_data['appid']
confkey_id = self.request.swagger_data['ckid']
configkey_req = self.request.swagger_data['configurationkey']
if self.is_valid_configurationkey(configkey_req):
ConfigurationKey.update(configkey_req.id, "name", configkey_req.name)
updated = ConfigurationKey.get(configkey_req.id)
return updated.as_dict()
print_log(datetime.datetime.now(), 'PUT', 'applications/%s/configurationkeys/%s' % (app_id, confkey_id),
'Update ConfigurationKey', 'Failed: Invalid Configurationkey')
return self.createResponse('Bad Request: invalid ConfigurationKey', 400)
def configurationkeys_DELETE_one(self):
""" Find and delete one configurationkey by id with delete method """
confkey_id = self.request.swagger_data['ckid']
app_id = self.request.swagger_data['appid']
confkey = get_conf_key_by_appid_and_ckid(app_id, confkey_id)
if not confkey:
print_log(datetime.datetime.now(), 'DELETE', '/applications/%s/' % app_id +
'/configurationkeys/%s/' % confkey_id,
'Delete configurationkey', 'Failed')
return self.createResponse(None, 400)
ConfigurationKey.destroy(confkey)
print_log(datetime.datetime.now(), 'DELETE', '/applications/%s' % app_id +
'/configurationkeys/%s' % confkey_id, 'Delete configurationkey', 'Succeeded')
return {}
def applications_GET_one(self):
""" Find and return one application by id with GET method """
app_id = self.request.swagger_data['id']
app = Application.get(app_id)
if app is None:
print_log(datetime.datetime.now(), 'GET',
'/applications/' + str(app_id), 'Get one application',
None)
return self.createResponse(None, 400)
if app.apikey is None:
app = self.set_app_apikey(app, app_id)
return app.as_dict()
def applications_DELETE_one(self):
""" Find and delete one application by id with delete method """
app_id = self.request.swagger_data['id']
app = Application.get(app_id)
if not app:
print_log(datetime.datetime.now(), 'DELETE',
'/applications/' + str(app_id), 'Delete application',
'Failed')
return self.createResponse(None, 400)
Application.destroy(app)
print_log(datetime.datetime.now(), 'DELETE',
'/applications/' + str(app_id), 'Delete application',
'Succeeded')
return {}
def experiments_GET_one(self):
""" Find and return one Application's Experiment by id with GET method """
app_id = self.request.swagger_data['appid']
exp_id = self.request.swagger_data['expid']
exp = Experiment.query().join(Application)\
.filter(Application.id == app_id, Experiment.id == exp_id).one_or_none()
if exp is None:
print_log(datetime.datetime.now(), 'GET',\
'/applications/%s/experiments/%s' % (app_id, exp_id),\
'Get one experiment', 'Failed')
return self.createResponse(None, 400)
exp_dict = exp.as_dict()
exp_dict['status'] = exp.get_status()
return exp_dict
def applications_POST(self):
""" Create new application with POST method """
req_app = self.request.swagger_data['application']
app = Application(
name=req_app.name,
apikey=self.get_unused_apikey(),
experiment_distribution=req_app.experiment_distribution)
if self.is_valid_application(req_app):
Application.save(app)
print_log(req_app.name, 'POST', '/applications',
'Create new application', app)
return app.as_dict()
print_log(req_app.name, 'POST', '/applications',
'Create new application', 'Failed: Invalid Application')
return self.createResponse('Bad Request: invalid Application', 400)
def configurations_GET(self):
client = get_client_by_id_and_app(self.request.swagger_data)
client_id = self.request.swagger_data['clientid']
app_id = self.request.swagger_data['appid']
if client is None:
print_log(
datetime.datetime.now(), 'GET',
'/applications/%s/clients/%s/configurations failed' %
(app_id, client_id), 'List configurations for specific client',
'Failed')
return self.createResponse(None, 400)
current_groups = client.experimentgroups
configs = list(map(lambda _: _.configurations, current_groups))
result = list(map(lambda _: _.as_dict(), list(concat(configs))))
return result
def get_client_configurations(client, application):
expgroup = assign_to_experimentgroup(client, application)
try:
configs = list(map(lambda _: _.as_dict(), expgroup.configurations))
except AttributeError as e:
# In this case, experimentgroup is None, and has already been logged
return None
if len(configs) == 0:
print_log(
datetime.datetime.now(), 'POST', '/configurations',
'Get client configurations',
'Failed: No Configurations on ExperimentGroup with id %s' %
expgroup.id)
return None
return configs
def experimentgroup_GET(self):
app_id = self.request.swagger_data['appid']
exp_id = self.request.swagger_data['expid']
experiment = Experiment.query().join(Application)\
.filter(Application.id == app_id, Experiment.id == exp_id)\
.one_or_none()
if experiment == None:
print_log(datetime.datetime.now(), 'GET', \
'/applications/%s/experiments/%s/experimentgroups' % ((app_id, exp_id)),
'List all ExperimentGroups for specific experiment', 'Failed')
return self.createResponse(None, 400)
experimentgroups = ExperimentGroup.query().filter(
ExperimentGroup.experiment_id == experiment.id)
return list(map(lambda _: _.as_dict(), experimentgroups))
def experiment_DELETE(self):
""" Delete one experiment """
app_id = self.request.swagger_data['appid']
exp_id = self.request.swagger_data['expid']
log_address = '/applications/%s/experiments/%s' % (app_id, exp_id)
exp = Experiment.query().join(Application)\
.filter(Application.id == app_id, Experiment.id == exp_id)\
.one_or_none()
if exp is None:
print_log(datetime.datetime.now(), 'DELETE', log_address,\
'Delete experiment', 'Failed')
return self.createResponse(None, 400)
Experiment.destroy(exp)
print_log(datetime.datetime.now(), 'DELETE', log_address,\
'Delete experiment', 'Succeeded')
return {}
def clients_for_experiment_GET(self):
""" List all clients for specific experiment """
app_id = self.request.swagger_data['appid']
exp_id = self.request.swagger_data['expid']
exp = Experiment.query().join(Application)\
.filter(Experiment.id == exp_id, Application.id == app_id)\
.one_or_none()
if exp == None:
print_log(datetime.datetime.now(), 'GET',
'/experiments/' + str(id) + '/clients',
'List all clients for specific experiment', 'Failed')
return self.createResponse(None, 400)
clients = Client.query()\
.join(Client.experimentgroups, Experiment, Application)\
.filter(Experiment.id == exp_id, Application.id == app_id).all()
return list(map(lambda _: _.as_dict(), clients))
def exclusionconstraints_DELETE_one(self):
""" Find and delete one exclusionconstraint by id with DELETE method """
app_id = self.request.swagger_data['appid']
exconst_id = self.request.swagger_data['ecid']
exconstraint = self.get_exclusionconstraint(app_id, exconst_id)
logmessage_address = '/applications/%s/exclusionconstraints/%s'\
% (app_id, exconst_id)
if exconstraint is None:
print_log(datetime.datetime.now(), 'DELETE', logmessage_address,
'Delete exclusionconstraint', 'Failed')
return self.createResponse(None, 400)
ExclusionConstraint.destroy(exconstraint)
print_log(datetime.datetime.now(), 'DELETE', logmessage_address,
'Delete exclusionconstraint', 'Succeeded')
return {}
def clients_GET(self):
"""
Explanation: maps as_dict() -function to every client-object (this is returned by client.all())
Creates a list and returns it. In future we might would like general json-serialization to make this even
more simpler.
"""
app_id = self.request.swagger_data['appid']
if not Application.get(app_id):
print_log('/applications/%s/clients failed' % app_id)
return self.createResponse(None, 400)
clients = Client.query()\
.join(Client.experimentgroups)\
.join(Experiment)\
.join(Application)\
.filter(Application.id == app_id)
return list(map(lambda _: _.as_dict(), clients))
def applications_PUT(self):
req_app = self.request.swagger_data['application']
req_app_id = self.request.swagger_data['id']
updated = Application.get(req_app_id)
if req_app_id != req_app.id or updated is None or not self.is_valid_application(
req_app):
print_log(
datetime.datetime.now(), 'PUT', '/applications/',
'Update Application',
'Failed: no such Application with id %s or ids didn\'t match' %
req_app_id)
return self.createResponse(None, 400)
Application.update(updated.id, "name", req_app.name)
Application.update(updated.id, "experiment_distribution",
req_app.experiment_distribution)
updated = Application.get(updated.id)
return updated.as_dict()
def assign_to_experimentgroup(client, application):
experiment = assign_to_experiment(client, application)
try:
expgroup = random.choice(list(experiment.experimentgroups))
except AttributeError as e:
# In this case, experiment is None, and has already been logged
return None
except IndexError as e:
print_log(
datetime.datetime.now(), 'POST', '/configurations',
'Get client configurations',
'Failed: No ExperimentGoups on Experiment with id %s' %
experiment.id)
return None
if expgroup not in client.experimentgroups:
client.experimentgroups.append(expgroup)
Client.flush()
return expgroup
def configurationkeys_POST(self):
"""
Create new configurationkey to application.
request.swagger_data['id'] takes the id and Application.get(app_id) returns the application by id.
"""
app_id = self.request.swagger_data['id']
application = Application.get(app_id)
if application is None:
print_log(datetime.datetime.now(), 'POST', '/applications/' + str(app_id) + '/configurationkeys',
'Create new configurationkey for application', 'Failed: No Application with id %s' % app_id)
return self.createResponse({}, 400)
new_confkey = self.request.swagger_data['configurationkey']
name = new_confkey.name
type = new_confkey.type.lower()
configurationkey = ConfigurationKey(
application=application,
name=name,
type=type
)
if self.is_valid_configurationkey(configurationkey):
ConfigurationKey.save(configurationkey)
print_log(datetime.datetime.now(), 'POST', '/applications/' + str(app_id) + '/configurationkeys',
'Create new configurationkey', 'Succeeded')
return configurationkey.as_dict()
print_log(datetime.datetime.now(), 'POST', '/applications/' + str(app_id) + '/configurationkeys',
'Create new configurationkey for application', 'Failed: Invalid ConfigurationKey')
return self.createResponse({}, 400)
def experimentgroup_GET_one(self):
"""
Show specific experiment group metadata
Metadata includes ExperimentGroup's configurations, Clients and DataItems
"""
app_id = self.request.swagger_data['appid']
expid = self.request.swagger_data['expid']
expgroupid = self.request.swagger_data['expgroupid']
#expgroup = ExperimentGroup.get(expgroupid)
expgroup = ExperimentGroup.query().join(Experiment, Application)\
.filter(ExperimentGroup.id == expgroupid, Experiment.id == expid,\
Application.id == app_id)\
.one_or_none()
if expgroup is None or expgroup.experiment.id != expid:
print_log(
datetime.datetime.now(), 'GET', '/experiments/' + str(expid) +
'/experimentgroups/' + str(expgroupid),
'Show specific experimentgroup metadata', None)
return self.createResponse(None, 400)
configurations = list(
map(lambda _: _.as_dict(), expgroup.configurations))
clients = list(map(lambda _: _.as_dict(), expgroup.clients))
dataitems = list(map(lambda _: _.dataitems, expgroup.clients))
dataitems_concat = list(concat(dataitems))
dataitems_with_client = []
for ditem in dataitems_concat:
dataitem = ditem.as_dict()
di_and_client = assoc(dataitem, 'client', ditem.client.as_dict())
dataitems_with_client.append(di_and_client)
experimentgroup = expgroup.as_dict()
resultwithconf = assoc(experimentgroup, 'configurations',
configurations)
resultwithclient = assoc(resultwithconf, 'clients', clients)
result = assoc(resultwithclient, 'dataitems', dataitems_with_client)
return result
